ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/rhd_qtree.c
Revision: 3.26
Committed: Fri Jan 7 20:33:02 2005 UTC (19 years, 2 months ago) by greg
Content type: text/plain
Branch: MAIN
CVS Tags: rad3R7P2, rad3R7P1, rad4R0, rad3R8, rad3R9
Changes since 3.25: +9 -9 lines
Log Message:
Modernized tone-mapping routines with structure pointer r.t. stack

File Contents

# Content
1 #ifndef lint
2 static const char RCSid[] = "$Id: rhd_qtree.c,v 3.25 2004/01/01 11:21:55 schorsch Exp $";
3 #endif
4 /*
5 * Quadtree driver support routines.
6 */
7
8 #include <string.h>
9
10 #include "standard.h"
11 #include "rhd_qtree.h"
12 /* quantity of leaves to free at a time */
13 #ifndef LFREEPCT
14 #define LFREEPCT 25
15 #endif
16 /* maximum allowed angle difference (deg.) */
17 #ifndef MAXANG
18 #define MAXANG 20
19 #endif
20 #if MAXANG>0
21 #define MAXDIFF2 ( MAXANG*MAXANG * (PI*PI/180./180.))
22 #endif
23
24 #define abs(i) ((i) < 0 ? -(i) : (i))
25
26 RTREE qtrunk; /* our quadtree trunk */
27 double qtDepthEps = .05; /* epsilon to compare depths (z fraction) */
28 int qtMinNodesiz = 2; /* minimum node dimension (pixels) */
29 struct rleaves qtL; /* our pile of leaves */
30
31 int rayqleft = 0; /* rays left to queue before flush */
32
33 static int32 falleaves; /* our list of fallen leaves */
34
35 #define composted(li) (qtL.bl <= qtL.tl ? \
36 ((li) < qtL.bl || (li) >= qtL.tl) : \
37 ((li) < qtL.bl && (li) >= qtL.tl))
38
39 #define TBUNDLESIZ 409 /* number of twigs in a bundle */
40
41 static RTREE **twigbundle; /* free twig blocks (NULL term.) */
42 static int nexttwig; /* next free twig */
43
44 static RTREE *newtwig(void);
45 static void qtFreeTree(int really);
46 static void shaketree(RTREE *tp);
47 static int putleaf(int li, int drop);
48
49
50 static RTREE *
51 newtwig(void) /* allocate a twig */
52 {
53 register int bi;
54
55 if (twigbundle == NULL) { /* initialize */
56 twigbundle = (RTREE **)malloc(sizeof(RTREE *));
57 if (twigbundle == NULL)
58 goto memerr;
59 twigbundle[0] = NULL;
60 }
61 bi = nexttwig / TBUNDLESIZ;
62 if (twigbundle[bi] == NULL) { /* new block */
63 twigbundle = (RTREE **)realloc((void *)twigbundle,
64 (bi+2)*sizeof(RTREE *));
65 if (twigbundle == NULL)
66 goto memerr;
67 twigbundle[bi] = (RTREE *)calloc(TBUNDLESIZ, sizeof(RTREE));
68 if (twigbundle[bi] == NULL)
69 goto memerr;
70 twigbundle[bi+1] = NULL;
71 }
72 /* nexttwig++ % TBUNDLESIZ */
73 return(twigbundle[bi] + (nexttwig++ - bi*TBUNDLESIZ));
74 memerr:
75 error(SYSTEM, "out of memory in newtwig");
76 return NULL; /* pro forma return */
77 }
78
79
80 static void
81 qtFreeTree( /* free allocated twigs */
82 int really
83 )
84 {
85 register int i;
86
87 qtrunk.flgs = CH_ANY; /* chop down tree */
88 if (twigbundle == NULL)
89 return;
90 i = (TBUNDLESIZ-1+nexttwig)/TBUNDLESIZ;
91 nexttwig = 0;
92 if (!really) { /* just clear allocated blocks */
93 while (i--)
94 memset((char *)twigbundle[i], '\0', TBUNDLESIZ*sizeof(RTREE));
95 return;
96 }
97 /* else "really" means free up memory */
98 for (i = 0; twigbundle[i] != NULL; i++)
99 free((void *)twigbundle[i]);
100 free((void *)twigbundle);
101 twigbundle = NULL;
102 }
103
104
105 #define LEAFSIZ (3*sizeof(float)+sizeof(int32)+\
106 sizeof(TMbright)+6*sizeof(BYTE))
107
108 extern int
109 qtAllocLeaves( /* allocate space for n leaves */
110 register int n
111 )
112 {
113 unsigned nbytes;
114 register unsigned i;
115
116 qtFreeTree(0); /* make sure tree is empty */
117 if (n <= 0)
118 return(0);
119 if (qtL.nl >= n)
120 return(qtL.nl);
121 else if (qtL.nl > 0)
122 free(qtL.base);
123 /* round space up to nearest power of 2 */
124 nbytes = n*LEAFSIZ + 8;
125 for (i = 1024; nbytes > i; i <<= 1)
126 ;
127 n = (i - 8) / LEAFSIZ; /* should we make sure n is even? */
128 qtL.base = (char *)malloc(n*LEAFSIZ);
129 if (qtL.base == NULL)
130 return(0);
131 /* assign larger alignment types earlier */
132 qtL.wp = (float (*)[3])qtL.base;
133 qtL.wd = (int32 *)(qtL.wp + n);
134 qtL.brt = (TMbright *)(qtL.wd + n);
135 qtL.chr = (BYTE (*)[3])(qtL.brt + n);
136 qtL.rgb = (BYTE (*)[3])(qtL.chr + n);
137 qtL.nl = n;
138 qtL.tml = qtL.bl = qtL.tl = 0;
139 falleaves = -1;
140 return(n);
141 }
142
143 #undef LEAFSIZ
144
145
146 extern void
147 qtFreeLeaves(void) /* free our allocated leaves and twigs */
148 {
149 qtFreeTree(1); /* free tree also */
150 if (qtL.nl <= 0)
151 return;
152 free(qtL.base);
153 qtL.base = NULL;
154 qtL.nl = 0;
155 }
156
157
158 static void
159 shaketree( /* shake dead leaves from tree */
160 register RTREE *tp
161 )
162 {
163 register int i, li;
164
165 for (i = 0; i < 4; i++)
166 if (tp->flgs & BRF(i)) {
167 shaketree(tp->k[i].b);
168 if (is_stump(tp->k[i].b))
169 tp->flgs &= ~BRF(i);
170 } else if (tp->flgs & LFF(i)) {
171 li = tp->k[i].li;
172 if (composted(li))
173 tp->flgs &= ~LFF(i);
174 }
175 }
176
177
178 extern int
179 qtCompost( /* free up some leaves */
180 int pct
181 )
182 {
183 register int32 *fl;
184 int nused, nclear, nmapped;
185 /* figure out how many leaves to clear */
186 nclear = qtL.nl * pct / 100;
187 nused = qtL.tl - qtL.bl;
188 if (nused <= 0) nused += qtL.nl;
189 nclear -= qtL.nl - nused;
190 if (nclear <= 0)
191 return(0);
192 if (nclear >= nused) { /* clear them all */
193 qtFreeTree(0);
194 qtL.tml = qtL.bl = qtL.tl = 0;
195 falleaves = -1;
196 return(nused);
197 }
198 /* else clear leaves from bottom */
199 nmapped = qtL.tml - qtL.bl;
200 if (nmapped < 0) nmapped += qtL.nl;
201 qtL.bl += nclear;
202 if (qtL.bl >= qtL.nl) qtL.bl -= qtL.nl;
203 if (nmapped <= nclear) qtL.tml = qtL.bl;
204 shaketree(&qtrunk); /* dereference composted leaves */
205 for (fl = &falleaves; *fl >= 0; fl = qtL.wd + *fl)
206 while (composted(*fl))
207 if ((*fl = qtL.wd[*fl]) < 0)
208 return(nclear);
209 return(nclear);
210 }
211
212
213 extern int
214 qtFindLeaf( /* find closest leaf to (x,y) */
215 int x,
216 int y
217 )
218 {
219 register RTREE *tp = &qtrunk;
220 int li = -1;
221 int x0=0, y0=0, x1=odev.hres, y1=odev.vres;
222 int mx, my;
223 register int q;
224 /* check limits */
225 if (x < 0 || x >= odev.hres || y < 0 || y >= odev.vres)
226 return(-1);
227 /* find nearby leaf in our tree */
228 for ( ; ; ) {
229 for (q = 0; q < 4; q++) /* find any leaf this level */
230 if (tp->flgs & LFF(q)) {
231 li = tp->k[q].li;
232 break;
233 }
234 q = 0; /* which quadrant are we? */
235 mx = (x0 + x1) >> 1;
236 my = (y0 + y1) >> 1;
237 if (x < mx) x1 = mx;
238 else {x0 = mx; q |= 01;}
239 if (y < my) y1 = my;
240 else {y0 = my; q |= 02;}
241 if (tp->flgs & BRF(q)) { /* branch down if not a leaf */
242 tp = tp->k[q].b;
243 continue;
244 }
245 if (tp->flgs & LFF(q)) /* good shot! */
246 return(tp->k[q].li);
247 return(li); /* else return what we have */
248 }
249 }
250
251
252 static int
253 putleaf( /* put a leaf in our tree */
254 register int li,
255 int drop
256 )
257 {
258 register RTREE *tp = &qtrunk;
259 int x0=0, y0=0, x1=odev.hres, y1=odev.vres;
260 register int lo = -1;
261 double d2;
262 int x, y, mx, my;
263 double z;
264 FVECT ip, wp, vd;
265 register int q;
266 /* check for dead leaf */
267 if (!qtL.chr[li][1] && !(qtL.chr[li][0] | qtL.chr[li][2]))
268 return(0);
269 /* compute leaf location in view */
270 VCOPY(wp, qtL.wp[li]);
271 viewloc(ip, &odev.v, wp);
272 if (ip[2] <= 0. || ip[0] < 0. || ip[0] >= 1.
273 || ip[1] < 0. || ip[1] >= 1.)
274 goto dropit; /* behind or outside view */
275 #ifdef DEBUG
276 if (odev.v.type == VT_PAR | odev.v.vfore > FTINY)
277 error(INTERNAL, "bad view assumption in putleaf");
278 #endif
279 for (q = 0; q < 3; q++)
280 vd[q] = (wp[q] - odev.v.vp[q])/ip[2];
281 d2 = fdir2diff(qtL.wd[li], vd);
282 #ifdef MAXDIFF2
283 if (d2 > MAXDIFF2)
284 goto dropit; /* leaf dir. too far off */
285 #endif
286 x = ip[0] * odev.hres;
287 y = ip[1] * odev.vres;
288 z = ip[2];
289 /* find the place for it */
290 for ( ; ; ) {
291 q = 0; /* which quadrant? */
292 mx = (x0 + x1) >> 1;
293 my = (y0 + y1) >> 1;
294 if (x < mx) x1 = mx;
295 else {x0 = mx; q |= 01;}
296 if (y < my) y1 = my;
297 else {y0 = my; q |= 02;}
298 if (tp->flgs & BRF(q)) { /* move to next branch */
299 tp->flgs |= CHF(q); /* not sure; guess */
300 tp = tp->k[q].b;
301 continue;
302 }
303 if (!(tp->flgs & LFF(q))) { /* found stem for leaf */
304 tp->k[q].li = li;
305 tp->flgs |= CHLFF(q);
306 return(1);
307 }
308 if (lo != tp->k[q].li) { /* check old leaf */
309 lo = tp->k[q].li;
310 VCOPY(wp, qtL.wp[lo]);
311 viewloc(ip, &odev.v, wp);
312 }
313 /* is node minimum size? */
314 if (y1-y0 <= qtMinNodesiz || x1-x0 <= qtMinNodesiz) {
315 if (z > (1.+qtDepthEps)*ip[2])
316 break; /* old one closer */
317 if (z >= (1.-qtDepthEps)*ip[2] &&
318 fdir2diff(qtL.wd[lo], vd) < d2)
319 break; /* old one better */
320 tp->k[q].li = li; /* attach new */
321 tp->flgs |= CHF(q);
322 li = lo; /* drop old... */
323 break;
324 }
325 tp->flgs &= ~LFF(q); /* else grow tree */
326 tp->flgs |= CHBRF(q);
327 tp = tp->k[q].b = newtwig();
328 q = 0; /* old leaf -> new branch */
329 mx = ip[0] * odev.hres;
330 my = ip[1] * odev.vres;
331 if (mx >= (x0 + x1) >> 1) q |= 01;
332 if (my >= (y0 + y1) >> 1) q |= 02;
333 tp->flgs = CH_ANY|LFF(q); /* all new */
334 tp->k[q].li = lo;
335 }
336 dropit:
337 if (drop) {
338 if (li+1 == (qtL.tl ? qtL.tl : qtL.nl))
339 qtL.tl = li; /* special case */
340 else {
341 qtL.chr[li][0] = qtL.chr[li][1] = qtL.chr[li][2] = 0;
342 qtL.wd[li] = falleaves;
343 falleaves = li;
344 }
345 }
346 return(li == lo);
347 }
348
349
350 extern void
351 dev_value( /* add a pixel value to our quadtree */
352 COLR c,
353 FVECT d,
354 FVECT p
355 )
356 {
357 register int li;
358 int mapit;
359 /* grab a leaf */
360 if (!imm_mode && falleaves >= 0) { /* check for fallen leaves */
361 li = falleaves;
362 falleaves = qtL.wd[li];
363 mapit = qtL.tml <= qtL.tl ?
364 (li < qtL.tml || li >= qtL.tl) :
365 (li < qtL.tml && li >= qtL.tl) ;
366 } else { /* else allocate new one */
367 li = qtL.tl++;
368 if (qtL.tl >= qtL.nl) /* next leaf in ring */
369 qtL.tl = 0;
370 if (qtL.tl == qtL.bl) /* need to shake some free */
371 qtCompost(LFREEPCT);
372 mapit = 0; /* we'll map it later */
373 }
374 if (p == NULL)
375 VSUM(qtL.wp[li], odev.v.vp, d, FHUGE);
376 else
377 VCOPY(qtL.wp[li], p);
378 qtL.wd[li] = encodedir(d);
379 tmCvColrs(tmGlobal, &qtL.brt[li], qtL.chr[li], (COLR *)c, 1);
380 if (putleaf(li, 1)) {
381 if (mapit)
382 tmMapPixels(tmGlobal, (BYTE *)(qtL.rgb+li), qtL.brt+li,
383 (BYTE *)(qtL.chr+li), 1);
384 if (--rayqleft == 0)
385 dev_flush(); /* flush output */
386 }
387 }
388
389
390 extern void
391 qtReplant(void) /* replant our tree using new view */
392 {
393 register int i;
394 /* anything to replant? */
395 if (qtL.bl == qtL.tl)
396 return;
397 qtFreeTree(0); /* blow the old tree away */
398 /* regrow it in new place */
399 for (i = qtL.bl; i != qtL.tl; ) {
400 putleaf(i, 0);
401 if (++i >= qtL.nl) i = 0;
402 }
403 }
404
405
406 extern int
407 qtMapLeaves( /* map our leaves to RGB */
408 int redo
409 )
410 {
411 int aorg, alen, borg, blen;
412 /* recompute mapping? */
413 if (redo)
414 qtL.tml = qtL.bl;
415 /* already done? */
416 if (qtL.tml == qtL.tl)
417 return(1);
418 /* compute segments */
419 aorg = qtL.tml;
420 if (qtL.tl >= aorg) {
421 alen = qtL.tl - aorg;
422 blen = 0;
423 } else {
424 alen = qtL.nl - aorg;
425 borg = 0;
426 blen = qtL.tl;
427 }
428 /* (re)compute tone mapping? */
429 if (qtL.tml == qtL.bl) {
430 tmClearHisto(tmGlobal);
431 tmAddHisto(tmGlobal, qtL.brt+aorg, alen, 1);
432 if (blen > 0)
433 tmAddHisto(tmGlobal, qtL.brt+borg, blen, 1);
434 if (tmComputeMapping(tmGlobal, 0., 0., 0.) != TM_E_OK)
435 return(0);
436 }
437 if (tmMapPixels(tmGlobal, (BYTE *)(qtL.rgb+aorg), qtL.brt+aorg,
438 (BYTE *)(qtL.chr+aorg), alen) != TM_E_OK)
439 return(0);
440 if (blen > 0)
441 tmMapPixels(tmGlobal, (BYTE *)(qtL.rgb+borg), qtL.brt+borg,
442 (BYTE *)(qtL.chr+borg), blen);
443 qtL.tml = qtL.tl;
444 return(1);
445 }