ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/rholo3.c
(Generate patch)

Comparing ray/src/hd/rholo3.c (file contents):
Revision 3.1 by gregl, Fri Oct 31 10:23:29 1997 UTC vs.
Revision 3.4 by gregl, Tue Nov 4 11:52:21 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 = 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) + n*sizeof(RAYVAL));
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 +                        bcopy((char *)hdbray(b), (char *)(p+1),
130 +                                        (p->nr=b->nrm)*sizeof(RAYVAL));
131 +                        disp_packet((PACKET *)p);
132 +                }
133 +        free((char *)p);                /* clean up */
134 +        return;
135 + memerr:
136 +        error(SYSTEM, "out of memory in bundle_set");
137 + }
138 +
139 +
140 + int
141   weightf(hp, x0, x1, x2)         /* voxel weighting function */
142   register HOLO   *hp;
143   register int    x0, x1, x2;
# Line 82 | Line 198 | int    x, y, z, dx, dy, dz;
198   }
199  
200  
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 –
201   init_global()                   /* initialize global ray computation */
202   {
203          long    wtotal = 0;
# Line 98 | Line 205 | init_global()                  /* initialize global ray computation *
205          int     lseg[2][3];
206          double  frac;
207          register int    k;
208 +                                        /* free old list */
209 +        if (complen > 0)
210 +                free((char *)complist);
211                                          /* allocate beam list */
212          complen = 0;
213          for (j = 0; hdlist[j] != NULL; j++)
# Line 126 | Line 236 | init_global()                  /* initialize global ray computation *
236                          while (k--)
237                                  complist[k].nr = frac * complist[k].nr;
238          }
239 <        listpos = 0; lastin = -1;
239 >        listpos = 0; lastin = -1;       /* flag initial sort */
240   }
241  
242  
# Line 156 | Line 266 | int    n1, n2;
266   sortcomplist()                  /* fix our list order */
267   {
268          PACKHEAD        *list2;
269 +        register int    i;
270 +
271                                  /* empty queue */
272          done_packets(flush_queue());
273 +        if (complen <= 0)       /* check to see if there is even a list */
274 +                return;
275          if (lastin < 0)         /* flag to sort entire list */
276                  qsort((char *)complist, complen, sizeof(PACKHEAD), beamcmp);
277          else if (listpos) {     /* else sort and merge sublist */
# Line 170 | Line 284 | sortcomplist()                 /* fix our list order */
284                                  complist+listpos, complen-listpos);
285                  free((char *)list2);
286          }
287 <        listpos = 0; lastin = complen-1;
287 >                                        /* check for all finished */
288 >        if (complist[0].nr <= bnrays(hdlist[complist[0].hd],complist[0].bi)) {
289 >                free((char *)complist);
290 >                complist = NULL;
291 >                complen = 0;
292 >        }
293 >                                        /* drop satisfied requests */
294 >        for (i = complen; i-- && complist[i].nr <=
295 >                        bnrays(hdlist[complist[i].hd],complist[i].bi); )
296 >                ;
297 >        if (i < 0) {
298 >                free((char *)complist);
299 >                complist = NULL;
300 >                complen = 0;
301 >        } else if (i < complen-1) {
302 >                list2 = (PACKHEAD *)realloc((char *)complist,
303 >                                (i+1)*sizeof(PACKHEAD));
304 >                if (list2 != NULL) {
305 >                        complist = list2;
306 >                        complen = i+1;
307 >                }
308 >        }
309 >        listpos = 0; lastin = i;
310   }
311  
312  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines