src/hd/rholo3.c

/* Copyright (c) 1997 Silicon Graphics, Inc. */

#ifndef lint
static char SCCSid[] = "$SunId$ SGI";
#endif

/*
 * Routines for tracking beam compuatations
 */

#include "rholo.h"


#define abs(x)          ((x) > 0 ? (x) : -(x))
#define sgn(x)          ((x) > 0 ? 1 : (x) < 0 ? -1 : 0)


static PACKHEAD *complist;      /* list of beams to compute */
static int      complen;        /* length of complist */
static int      listpos;        /* current list position for next_packet */
static int      lastin = -1;    /* last ordered position in list */


int
beamcmp(b0, b1)                 /* comparison for descending compute order */
register PACKHEAD       *b0, *b1;
{
        return( b1->nr*(bnrays(hdlist[b0->hd],b0->bi)+1) -
                b0->nr*(bnrays(hdlist[b1->hd],b1->bi)+1) );
}


bundle_set(op, clist, nents)    /* bundle set operation */
int     op;
PACKHEAD        *clist;
int     nents;
{
        BEAM    *b;
        PACKHEAD        *p;
        register int    i, n;

        switch (op) {
        case BS_NEW:                    /* new computation set */
                if (complen)
                        free((char *)complist);
                if (nents <= 0) {
                        complist = NULL;
                        listpos = complen = 0;
                        lastin = -1;
                        return;
                }
                complist = (PACKHEAD *)malloc(nents*sizeof(PACKHEAD));
                if (complist == NULL)
                        goto memerr;
                bcopy((char *)clist, (char *)complist, nents*sizeof(PACKHEAD));
                complen = nents;
                listpos = 0;
                lastin = -1;            /* flag for initial sort */
                break;
        case BS_ADD:                    /* add to computation set */
                if (nents <= 0)
                        return;
                                        /* merge any common members */
                for (i = 0; i < complen; i++)
                        for (n = 0; n < nents; n++)
                                if (clist[n].bi == complist[i].bi &&
                                                clist[n].hd == complist[i].hd) {
                                        complist[i].nr += clist[n].nr;
                                        clist[n].nr = 0;
                                        lastin = -1;    /* flag full sort */
                                        break;
                                }
                                        /* sort updated list */
                sortcomplist();
                                        /* sort new entries */
                qsort((char *)clist, nents, sizeof(PACKHEAD), beamcmp);
                                        /* what can't we satisfy? */
                for (n = 0; n < nents && clist[n].nr >
                                bnrays(hdlist[clist[n].hd],clist[n].bi); n++)
                        ;
                if (n) {                /* allocate space for merged list */
                        PACKHEAD        *newlist;
                        newlist = (PACKHEAD *)malloc(
                                        (complen+n)*sizeof(PACKHEAD) );
                        if (newlist == NULL)
                                goto memerr;
                                                /* merge lists */
                        mergeclists(newlist, clist, n, complist, complen);
                        if (complen)
                                free((char *)complist);
                        complist = newlist;
                        complen += n;
                }
                listpos = 0;
                lastin = complen-1;     /* list is now sorted */
                break;
        case BS_DEL:                    /* delete from computation set */
                if (nents <= 0)
                        return;
                                        /* find each member */
                for (i = 0; i < complen; i++)
                        for (n = 0; n < nents; n++)
                                if (clist[n].bi == complist[i].bi &&
                                                clist[n].hd == complist[i].hd) {
                                        if (clist[n].nr == 0 ||
                                                clist[n].nr >= complist[i].nr)
                                                complist[i].nr = 0;
                                        else
                                                complist[i].nr -= clist[n].nr;
                                        lastin = -1;    /* flag full sort */
                                        break;
                                }
                                        /* sort updated list */
                sortcomplist();
                return;                 /* no display */
        default:
                error(CONSISTENCY, "bundle_set called with unknown operation");
        }
        n = 0;                          /* allocate packet holder */
        for (i = 0; i < nents; i++)
                if (clist[i].nr > n)
                        n = clist[i].nr;
        p = (PACKHEAD *)malloc(sizeof(PACKHEAD) + n*sizeof(RAYVAL));
                                        /* now, display what we can */
        for (i = 0; i < nents; i++)
                if (clist[i].nr > 0 &&
                (b = hdgetbeam(hdlist[clist[i].hd], clist[i].bi)) != NULL) {
                        bcopy((char *)hdbray(b), (char *)(p+1),
                                        (p->nr=b->nrm)*sizeof(RAYVAL));
                        disp_packet((PACKET *)p);
                }
        free((char *)p);                /* clean up */
        return;
memerr:
        error(SYSTEM, "out of memory in bundle_set");
}


int
weightf(hp, x0, x1, x2)         /* voxel weighting function */
register HOLO   *hp;
register int    x0, x1, x2;
{
        switch (vlet(OCCUPANCY)) {
        case 'U':               /* uniform weighting */
                return(1);
        case 'C':               /* center weighting (crude) */
                x0 += x0 - hp->grid[0] + 1;
                x0 = abs(x0)*hp->grid[1]*hp->grid[2];
                x1 += x1 - hp->grid[1] + 1;
                x1 = abs(x1)*hp->grid[0]*hp->grid[2];
                x2 += x2 - hp->grid[2] + 1;
                x2 = abs(x2)*hp->grid[0]*hp->grid[1];
                return(hp->grid[0]*hp->grid[1]*hp->grid[2] -
                                (x0+x1+x2)/3);
        default:
                badvalue(OCCUPANCY);
        }
}


/* The following is by Daniel Cohen, taken from Graphics Gems IV, p. 368 */
long
lineweight(hp, x, y, z, dx, dy, dz)     /* compute weights along a line */
HOLO    *hp;
int     x, y, z, dx, dy, dz;
{
        long    wres = 0;
        int     n, sx, sy, sz, exy, exz, ezy, ax, ay, az, bx, by, bz;

        sx = sgn(dx);   sy = sgn(dy);   sz = sgn(dz);
        ax = abs(dx);   ay = abs(dy);   az = abs(dz);
        bx = 2*ax;      by = 2*ay;      bz = 2*az;
        exy = ay-ax;    exz = az-ax;    ezy = ay-az;
        n = ax+ay+az + 1;               /* added increment to visit last */
        while (n--) {
                wres += weightf(hp, x, y, z);
                if (exy < 0) {
                        if (exz < 0) {
                                x += sx;
                                exy += by; exz += bz;
                        } else {
                                z += sz;
                                exz -= bx; ezy += by;
                        }
                } else {
                        if (ezy < 0) {
                                z += sz;
                                exz -= bx; ezy += by;
                        } else {
                                y += sy;
                                exy -= bx; ezy -= bz;
                        }
                }
        }
        return(wres);
}


init_global()                   /* initialize global ray computation */
{
        long    wtotal = 0;
        int     i, j;
        int     lseg[2][3];
        double  frac;
        register int    k;
                                        /* allocate beam list */
        complen = 0;
        for (j = 0; hdlist[j] != NULL; j++)
                complen += nbeams(hdlist[j]);
        complist = (PACKHEAD *)malloc(complen*sizeof(PACKHEAD));
        if (complist == NULL)
                error(SYSTEM, "out of memory in init_global");
                                        /* compute beam weights */
        k = 0;
        for (j = 0; hdlist[j] != NULL; j++)
                for (i = nbeams(hdlist[j]); i > 0; i--) {
                        hdlseg(lseg, hdlist[j], i);
                        complist[k].hd = j;
                        complist[k].bi = i;
                        complist[k].nr = lineweight( hdlist[j],
                                        lseg[0][0], lseg[0][1], lseg[0][2],
                                        lseg[1][0] - lseg[0][0],
                                        lseg[1][1] - lseg[0][1],
                                        lseg[1][2] - lseg[0][2] );
                        wtotal += complist[k++].nr;
                }
                                        /* adjust weights */
        if (vdef(DISKSPACE)) {
                frac = 1024.*1024.*vflt(DISKSPACE) / (wtotal*sizeof(RAYVAL));
                if (frac < 0.95 | frac > 1.05)
                        while (k--)
                                complist[k].nr = frac * complist[k].nr;
        }
        listpos = 0; lastin = -1;
}


mergeclists(cdest, cl1, n1, cl2, n2)    /* merge two sorted lists */
PACKHEAD        *cdest;
PACKHEAD        *cl1, *cl2;
int     n1, n2;
{
        int     cmp;

        while (n1 | n2) {
                if (!n1) cmp = 1;
                else if (!n2) cmp = -1;
                else cmp = beamcmp(cl1, cl2);
                if (cmp > 0) {
                        copystruct(cdest, cl2);
                        cl2++; n2--;
                } else {
                        copystruct(cdest, cl1);
                        cl1++; n1--;
                }
                cdest++;
        }
}


sortcomplist()                  /* fix our list order */
{
        PACKHEAD        *list2;
        register int    i;

                                /* empty queue */
        done_packets(flush_queue());
        if (complen <= 0)       /* check to see if there even is a list */
                return;
        if (lastin < 0)         /* flag to sort entire list */
                qsort((char *)complist, complen, sizeof(PACKHEAD), beamcmp);
        else if (listpos) {     /* else sort and merge sublist */
                list2 = (PACKHEAD *)malloc(listpos*sizeof(PACKHEAD));
                if (list2 == NULL)
                        error(SYSTEM, "out of memory in sortcomplist");
                bcopy((char *)complist,(char *)list2,listpos*sizeof(PACKHEAD));
                qsort((char *)list2, listpos, sizeof(PACKHEAD), beamcmp);
                mergeclists(complist, list2, listpos,
                                complist+listpos, complen-listpos);
                free((char *)list2);
        }
                                        /* check for all finished */
        if (complist[0].nr <= bnrays(hdlist[complist[0].hd],complist[0].bi)) {
                free((char *)complist);
                complist = NULL;
                complen = 0;
        }
                                        /* drop satisfied requests */
        for (i = complen; i-- && complist[i].nr <=
                        bnrays(hdlist[complist[i].hd],complist[i].bi); )
                ;
        if (i < complen-1) {
                list2 = (PACKHEAD *)realloc((char *)complist,
                                (i+1)*sizeof(PACKHEAD));
                if (list2 != NULL) {
                        complist = list2;
                        complen = i+1;
                }
        }
        listpos = 0; lastin = i;
}


/*
 * The following routine works on the assumption that the bundle weights are
 * more or less evenly distributed, such that computing a packet causes
 * a given bundle to move way down in the computation order.  We keep
 * track of where the computed bundle with the highest priority would end
 * up, and if we get further in our compute list than this, we resort the
 * list and start again from the beginning.  We have to flush the queue
 * each time we sort, to ensure that we are not disturbing the order.
 *      If our major assumption is violated, and we have a very steep
 * descent in our weights, then we will end up resorting much more often
 * than necessary, resulting in frequent flushing of the queue.  Since
 * a merge sort is used, the sorting costs will be minimal.
 */
next_packet(p)                  /* prepare packet for computation */
register PACKET *p;
{
        int     ncomp;
        register int    i;

        if (complen <= 0)
                return(0);
        if (listpos > lastin)           /* time to sort the list */
                sortcomplist();
        p->hd = complist[listpos].hd;
        p->bi = complist[listpos].bi;
        ncomp = bnrays(hdlist[p->hd],p->bi);
        p->nr = complist[listpos].nr - ncomp;
        if (p->nr <= 0)
                return(0);
        if (p->nr > RPACKSIZ)
                p->nr = RPACKSIZ;
        ncomp += p->nr;                 /* find where this one would go */
        while (lastin > listpos && complist[listpos].nr *
                (bnrays(hdlist[complist[lastin].hd],complist[lastin].bi)+1)
                        > complist[lastin].nr * (ncomp+1))
                lastin--;
        listpos++;
        return(1);
}
Revision:	3.2
Committed:	Mon Nov 3 18:33:13 1997 UTC (26 years, 11 months ago) by gregl
Content type:	text/plain
Branch:	MAIN
Changes since 3.1:	+140 -12 lines
Log Message:	added more routines for display support
#	User	Rev	Content
1	gregl	3.1	/* Copyright (c) 1997 Silicon Graphics, Inc. */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ SGI";
5			#endif
6
7			/*
8			* Routines for tracking beam compuatations
9			*/
10
11			#include "rholo.h"
12
13
14			#define abs(x) ((x) > 0 ? (x) : -(x))
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	gregl	3.2	static int listpos; /* current list position for next_packet */
21			static int lastin = -1; /* last ordered position in list */
22	gregl	3.1
23
24			int
25	gregl	3.2	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(nentssizeof(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			/* sort updated list */
114			sortcomplist();
115			return; /* no display */
116			default:
117			error(CONSISTENCY, "bundle_set called with unknown operation");
118			}
119			n = 0; /* 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(sizeof(PACKHEAD) + nsizeof(RAYVAL));
124			/* now, display what we can */
125			for (i = 0; i < nents; i++)
126			if (clist[i].nr > 0 &&
127			(b = hdgetbeam(hdlist[clist[i].hd], clist[i].bi)) != NULL) {
128			bcopy((char )hdbray(b), (char )(p+1),
129			(p->nr=b->nrm)*sizeof(RAYVAL));
130			disp_packet((PACKET *)p);
131			}
132			free((char )p); / clean up */
133			return;
134			memerr:
135			error(SYSTEM, "out of memory in bundle_set");
136			}
137
138
139			int
140	gregl	3.1	weightf(hp, x0, x1, x2) /* voxel weighting function */
141			register HOLO *hp;
142			register int x0, x1, x2;
143			{
144			switch (vlet(OCCUPANCY)) {
145			case 'U': /* uniform weighting */
146			return(1);
147			case 'C': /* center weighting (crude) */
148			x0 += x0 - hp->grid[0] + 1;
149			x0 = abs(x0)hp->grid[1]hp->grid[2];
150			x1 += x1 - hp->grid[1] + 1;
151			x1 = abs(x1)hp->grid[0]hp->grid[2];
152			x2 += x2 - hp->grid[2] + 1;
153			x2 = abs(x2)hp->grid[0]hp->grid[1];
154			return(hp->grid[0]hp->grid[1]hp->grid[2] -
155			(x0+x1+x2)/3);
156			default:
157			badvalue(OCCUPANCY);
158			}
159			}
160
161
162			/* The following is by Daniel Cohen, taken from Graphics Gems IV, p. 368 */
163			long
164			lineweight(hp, x, y, z, dx, dy, dz) /* compute weights along a line */
165			HOLO *hp;
166			int x, y, z, dx, dy, dz;
167			{
168			long wres = 0;
169			int n, sx, sy, sz, exy, exz, ezy, ax, ay, az, bx, by, bz;
170
171			sx = sgn(dx); sy = sgn(dy); sz = sgn(dz);
172			ax = abs(dx); ay = abs(dy); az = abs(dz);
173			bx = 2ax; by = 2ay; bz = 2*az;
174			exy = ay-ax; exz = az-ax; ezy = ay-az;
175			n = ax+ay+az + 1; /* added increment to visit last */
176			while (n--) {
177			wres += weightf(hp, x, y, z);
178			if (exy < 0) {
179			if (exz < 0) {
180			x += sx;
181			exy += by; exz += bz;
182			} else {
183			z += sz;
184			exz -= bx; ezy += by;
185			}
186			} else {
187			if (ezy < 0) {
188			z += sz;
189			exz -= bx; ezy += by;
190			} else {
191			y += sy;
192			exy -= bx; ezy -= bz;
193			}
194			}
195			}
196			return(wres);
197			}
198
199
200			init_global() /* initialize global ray computation */
201			{
202			long wtotal = 0;
203			int i, j;
204			int lseg[2][3];
205			double frac;
206			register int k;
207			/* allocate beam list */
208			complen = 0;
209			for (j = 0; hdlist[j] != NULL; j++)
210			complen += nbeams(hdlist[j]);
211			complist = (PACKHEAD )malloc(complensizeof(PACKHEAD));
212			if (complist == NULL)
213			error(SYSTEM, "out of memory in init_global");
214			/* compute beam weights */
215			k = 0;
216			for (j = 0; hdlist[j] != NULL; j++)
217			for (i = nbeams(hdlist[j]); i > 0; i--) {
218			hdlseg(lseg, hdlist[j], i);
219			complist[k].hd = j;
220			complist[k].bi = i;
221			complist[k].nr = lineweight( hdlist[j],
222			lseg[0][0], lseg[0][1], lseg[0][2],
223			lseg[1][0] - lseg[0][0],
224			lseg[1][1] - lseg[0][1],
225			lseg[1][2] - lseg[0][2] );
226			wtotal += complist[k++].nr;
227			}
228			/* adjust weights */
229			if (vdef(DISKSPACE)) {
230			frac = 1024.1024.vflt(DISKSPACE) / (wtotal*sizeof(RAYVAL));
231			if (frac < 0.95 \| frac > 1.05)
232			while (k--)
233			complist[k].nr = frac * complist[k].nr;
234			}
235			listpos = 0; lastin = -1;
236			}
237
238
239			mergeclists(cdest, cl1, n1, cl2, n2) /* merge two sorted lists */
240			PACKHEAD *cdest;
241			PACKHEAD cl1, cl2;
242			int n1, n2;
243			{
244			int cmp;
245
246			while (n1 \| n2) {
247			if (!n1) cmp = 1;
248			else if (!n2) cmp = -1;
249			else cmp = beamcmp(cl1, cl2);
250			if (cmp > 0) {
251			copystruct(cdest, cl2);
252			cl2++; n2--;
253			} else {
254			copystruct(cdest, cl1);
255			cl1++; n1--;
256			}
257			cdest++;
258			}
259			}
260
261
262			sortcomplist() /* fix our list order */
263			{
264			PACKHEAD *list2;
265	gregl	3.2	register int i;
266
267	gregl	3.1	/* empty queue */
268			done_packets(flush_queue());
269	gregl	3.2	if (complen <= 0) /* check to see if there even is a list */
270			return;
271	gregl	3.1	if (lastin < 0) /* flag to sort entire list */
272			qsort((char *)complist, complen, sizeof(PACKHEAD), beamcmp);
273			else if (listpos) { /* else sort and merge sublist */
274			list2 = (PACKHEAD )malloc(listpossizeof(PACKHEAD));
275			if (list2 == NULL)
276			error(SYSTEM, "out of memory in sortcomplist");
277			bcopy((char )complist,(char )list2,listpos*sizeof(PACKHEAD));
278			qsort((char *)list2, listpos, sizeof(PACKHEAD), beamcmp);
279			mergeclists(complist, list2, listpos,
280			complist+listpos, complen-listpos);
281			free((char *)list2);
282			}
283	gregl	3.2	/* check for all finished */
284			if (complist[0].nr <= bnrays(hdlist[complist[0].hd],complist[0].bi)) {
285			free((char *)complist);
286			complist = NULL;
287			complen = 0;
288			}
289			/* drop satisfied requests */
290			for (i = complen; i-- && complist[i].nr <=
291			bnrays(hdlist[complist[i].hd],complist[i].bi); )
292			;
293			if (i < complen-1) {
294			list2 = (PACKHEAD )realloc((char )complist,
295			(i+1)*sizeof(PACKHEAD));
296			if (list2 != NULL) {
297			complist = list2;
298			complen = i+1;
299			}
300			}
301			listpos = 0; lastin = i;
302	gregl	3.1	}
303
304
305			/*
306			* The following routine works on the assumption that the bundle weights are
307			* more or less evenly distributed, such that computing a packet causes
308			* a given bundle to move way down in the computation order. We keep
309			* track of where the computed bundle with the highest priority would end
310			* up, and if we get further in our compute list than this, we resort the
311			* list and start again from the beginning. We have to flush the queue
312			* each time we sort, to ensure that we are not disturbing the order.
313			* If our major assumption is violated, and we have a very steep
314			* descent in our weights, then we will end up resorting much more often
315			* than necessary, resulting in frequent flushing of the queue. Since
316			* a merge sort is used, the sorting costs will be minimal.
317			*/
318			next_packet(p) /* prepare packet for computation */
319			register PACKET *p;
320			{
321			int ncomp;
322			register int i;
323
324			if (complen <= 0)
325			return(0);
326			if (listpos > lastin) /* time to sort the list */
327			sortcomplist();
328			p->hd = complist[listpos].hd;
329			p->bi = complist[listpos].bi;
330			ncomp = bnrays(hdlist[p->hd],p->bi);
331			p->nr = complist[listpos].nr - ncomp;
332			if (p->nr <= 0)
333			return(0);
334			if (p->nr > RPACKSIZ)
335			p->nr = RPACKSIZ;
336			ncomp += p->nr; /* find where this one would go */
337			while (lastin > listpos && complist[listpos].nr *
338			(bnrays(hdlist[complist[lastin].hd],complist[lastin].bi)+1)
339			> complist[lastin].nr * (ncomp+1))
340			lastin--;
341			listpos++;
342			return(1);
343			}