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

Comparing ray/src/gen/mkillum4.c (file contents):
Revision 2.2 by greg, Fri Sep 21 05:53:21 2007 UTC vs.
Revision 2.7 by greg, Wed Dec 12 05:09:58 2007 UTC

# Line 9 | Line 9 | static const char RCSid[] = "$Id$";
9   #include "paths.h"
10   #include "ezxml.h"
11  
12 + #define MAXLATS         46              /* maximum number of latitudes */
13  
14 + /* BSDF angle specification (terminate with nphi = -1) */
15 + typedef struct {
16 +        char    name[64];               /* basis name */
17 +        int     nangles;                /* total number of directions */
18 +        struct {
19 +                float   tmin;                   /* starting theta */
20 +                short   nphis;                  /* number of phis (0 term) */
21 +        }       lat[MAXLATS+1];         /* latitudes */
22 + } ANGLE_BASIS;
23 +
24 + #define MAXABASES       3               /* limit on defined bases */
25 +
26 + ANGLE_BASIS     abase_list[MAXABASES] = {
27 +        {
28 +                "LBNL/Klems Full", 145,
29 +                { {-5., 1},
30 +                {5., 8},
31 +                {15., 16},
32 +                {25., 20},
33 +                {35., 24},
34 +                {45., 24},
35 +                {55., 24},
36 +                {65., 16},
37 +                {75., 12},
38 +                {90., 0} }
39 +        }, {
40 +                "LBNL/Klems Half", 73,
41 +                { {-6.5, 1},
42 +                {6.5, 8},
43 +                {19.5, 12},
44 +                {32.5, 16},
45 +                {46.5, 20},
46 +                {61.5, 12},
47 +                {76.5, 4},
48 +                {90., 0} }
49 +        }, {
50 +                "LBNL/Klems Quarter", 41,
51 +                { {-9., 1},
52 +                {9., 8},
53 +                {27., 12},
54 +                {46., 12},
55 +                {66., 8},
56 +                {90., 0} }
57 +        }
58 + };
59 +
60 + static int      nabases = 3;    /* current number of defined bases */
61 +
62 +
63 + static int
64 + ab_getvec(              /* get vector for this angle basis index */
65 +        FVECT v,
66 +        int ndx,
67 +        void *p
68 + )
69 + {
70 +        ANGLE_BASIS  *ab = (ANGLE_BASIS *)p;
71 +        int     li;
72 +        double  alt, azi, d;
73 +        
74 +        if ((ndx < 0) | (ndx >= ab->nangles))
75 +                return(0);
76 +        for (li = 0; ndx >= ab->lat[li].nphis; li++)
77 +                ndx -= ab->lat[li].nphis;
78 +        alt = PI/180.*0.5*(ab->lat[li].tmin + ab->lat[li+1].tmin);
79 +        azi = 2.*PI*ndx/ab->lat[li].nphis;
80 +        d = sin(alt);
81 +        v[0] = cos(azi)*d;
82 +        v[1] = sin(azi)*d;
83 +        v[2] = cos(alt);
84 +        return(1);
85 + }
86 +
87 +
88 + static int
89 + ab_getndx(              /* get index corresponding to the given vector */
90 +        FVECT v,
91 +        void *p
92 + )
93 + {
94 +        ANGLE_BASIS  *ab = (ANGLE_BASIS *)p;
95 +        int     li, ndx;
96 +        double  alt, azi, d;
97 +
98 +        if ((v[2] < -1.0) | (v[2] > 1.0))
99 +                return(-1);
100 +        alt = 180.0/PI*acos(v[2]);
101 +        azi = 180.0/PI*atan2(v[1], v[0]);
102 +        if (azi < 0.0) azi += 360.0;
103 +        for (li = 1; ab->lat[li].tmin <= alt; li++)
104 +                if (!ab->lat[li].nphis)
105 +                        return(-1);
106 +        --li;
107 +        ndx = (int)((1./360.)*azi*ab->lat[li].nphis + 0.5);
108 +        if (ndx >= ab->lat[li].nphis) ndx = 0;
109 +        while (li--)
110 +                ndx += ab->lat[li].nphis;
111 +        return(ndx);
112 + }
113 +
114 +
115 + static double
116 + ab_getohm(              /* get solid angle for this angle basis index */
117 +        int ndx,
118 +        void *p
119 + )
120 + {
121 +        ANGLE_BASIS  *ab = (ANGLE_BASIS *)p;
122 +        int     li;
123 +        double  tdia, pdia;
124 +        
125 +        if ((ndx < 0) | (ndx >= ab->nangles))
126 +                return(0);
127 +        for (li = 0; ndx >= ab->lat[li].nphis; li++)
128 +                ndx -= ab->lat[li].nphis;
129 +        if (ab->lat[li].nphis == 1) {           /* special case */
130 +                if (ab->lat[li].tmin > FTINY)
131 +                        error(USER, "unsupported BSDF coordinate system");
132 +                tdia = PI/180. * ab->lat[li+1].tmin;
133 +                return(PI*tdia*tdia);
134 +        }
135 +        tdia = PI/180.*(ab->lat[li+1].tmin - ab->lat[li].tmin);
136 +        tdia *= sin(PI/180.*(ab->lat[li].tmin + ab->lat[li+1].tmin));
137 +        pdia = 2.*PI/ab->lat[li].nphis;
138 +        return(tdia*pdia);
139 + }
140 +
141 +
142 + static int
143 + ab_getvecR(             /* get reverse vector for this angle basis index */
144 +        FVECT v,
145 +        int ndx,
146 +        void *p
147 + )
148 + {
149 +        if (!ab_getvec(v, ndx, p))
150 +                return(0);
151 +
152 +        v[0] = -v[0];
153 +        v[1] = -v[1];
154 +
155 +        return(1);
156 + }
157 +
158 +
159 + static int
160 + ab_getndxR(             /* get index corresponding to the reverse vector */
161 +        FVECT v,
162 +        void *p
163 + )
164 + {
165 +        FVECT  v2;
166 +        
167 +        v2[0] = -v[0];
168 +        v2[1] = -v[1];
169 +        v2[2] = v[2];
170 +
171 +        return ab_getndx(v2, p);
172 + }
173 +
174 +
175 + static void
176 + load_bsdf_data(         /* load BSDF distribution for this wavelength */
177 +        struct BSDF_data *dp,
178 +        ezxml_t wdb
179 + )
180 + {
181 +        char  *cbasis = ezxml_txt(ezxml_child(wdb,"ColumnAngleBasis"));
182 +        char  *rbasis = ezxml_txt(ezxml_child(wdb,"RowAngleBasis"));
183 +        char  *sdata;
184 +        int  i;
185 +        
186 +        if ((cbasis == NULL) | (rbasis == NULL)) {
187 +                error(WARNING, "missing column/row basis for BSDF");
188 +                return;
189 +        }
190 +        /* XXX need to add routines for loading in foreign bases */
191 +        for (i = nabases; i--; )
192 +                if (!strcmp(cbasis, abase_list[i].name)) {
193 +                        dp->ninc = abase_list[i].nangles;
194 +                        dp->ib_priv = (void *)&abase_list[i];
195 +                        dp->ib_vec = ab_getvec;
196 +                        dp->ib_ndx = ab_getndx;
197 +                        dp->ib_ohm = ab_getohm;
198 +                        break;
199 +                }
200 +        if (i < 0) {
201 +                sprintf(errmsg, "unsupported ColumnAngleBasis '%s'", cbasis);
202 +                error(WARNING, errmsg);
203 +                return;
204 +        }
205 +        for (i = nabases; i--; )
206 +                if (!strcmp(rbasis, abase_list[i].name)) {
207 +                        dp->nout = abase_list[i].nangles;
208 +                        dp->ob_priv = (void *)&abase_list[i];
209 +                        dp->ob_vec = ab_getvecR;
210 +                        dp->ob_ndx = ab_getndxR;
211 +                        dp->ob_ohm = ab_getohm;
212 +                        break;
213 +                }
214 +        if (i < 0) {
215 +                sprintf(errmsg, "unsupported RowAngleBasis '%s'", cbasis);
216 +                error(WARNING, errmsg);
217 +                return;
218 +        }
219 +                                /* read BSDF data */
220 +        sdata  = ezxml_txt(ezxml_child(wdb,"ScatteringData"));
221 +        if (sdata == NULL) {
222 +                error(WARNING, "missing BSDF ScatteringData");
223 +                return;
224 +        }
225 +        dp->bsdf = (float *)malloc(sizeof(float)*dp->ninc*dp->nout);
226 +        if (dp->bsdf == NULL)
227 +                error(SYSTEM, "out of memory in load_bsdf_data");
228 +        for (i = 0; i < dp->ninc*dp->nout; i++) {
229 +                char  *sdnext = fskip(sdata);
230 +                if (sdnext == NULL) {
231 +                        error(WARNING, "bad/missing BSDF ScatteringData");
232 +                        free(dp->bsdf); dp->bsdf = NULL;
233 +                        return;
234 +                }
235 +                while (*sdnext && isspace(*sdnext))
236 +                        sdnext++;
237 +                if (*sdnext == ',') sdnext++;
238 +                dp->bsdf[i] = atof(sdata);
239 +                sdata = sdnext;
240 +        }
241 +        while (isspace(*sdata))
242 +                sdata++;
243 +        if (*sdata) {
244 +                sprintf(errmsg, "%d extra characters after BSDF ScatteringData",
245 +                                strlen(sdata));
246 +                error(WARNING, errmsg);
247 +        }
248 + }
249 +
250 +
251   struct BSDF_data *
252   load_BSDF(              /* load BSDF data from file */
253          char *fname
# Line 31 | Line 269 | load_BSDF(             /* load BSDF data from file */
269                  error(WARNING, errmsg);
270                  return(NULL);
271          }
272 <        dp = (struct BSDF_data *)malloc(sizeof(struct BSDF_data));
273 <        if (dp == NULL)
274 <                goto memerr;
272 >        if (ezxml_error(fl)[0]) {
273 >                sprintf(errmsg, "BSDF \"%s\": %s", path, ezxml_error(fl));
274 >                error(WARNING, errmsg);
275 >                ezxml_free(fl);
276 >                return(NULL);
277 >        }
278 >        dp = (struct BSDF_data *)calloc(1, sizeof(struct BSDF_data));
279          for (wld = ezxml_child(fl, "WavelengthData");
280                                  fl != NULL; fl = fl->next) {
281 <                if (strcmp(ezxml_child(wld, "Wavelength")->txt, "Visible"))
281 >                if (strcmp(ezxml_txt(ezxml_child(wld,"Wavelength")), "Visible"))
282                          continue;
283                  wdb = ezxml_child(wld, "WavelengthDataBlock");
284                  if (wdb == NULL) continue;
285 <                if (strcmp(ezxml_child(wdb, "WavelengthDataDirection")->txt,
285 >                if (strcmp(ezxml_txt(ezxml_child(wdb,"WavelengthDataDirection")),
286                                          "Transmission Front"))
287                          continue;
288 +                load_bsdf_data(dp, wdb);        /* load front BTDF */
289 +                break;                          /* ignore the rest */
290          }
291 <        /* etc... */
292 <        ezxml_free(fl);
291 >        ezxml_free(fl);                         /* done with XML file */
292 >        if (dp->bsdf == NULL) {
293 >                sprintf(errmsg, "bad/missing BTDF data in \"%s\"", path);
294 >                error(WARNING, errmsg);
295 >                free_BSDF(dp);
296 >                dp = NULL;
297 >        }
298          return(dp);
50 – memerr:
51 –        error(SYSTEM, "out of memory in load_BSDF");
52 –        return NULL;    /* pro forma return */
299   }
300  
301  
# Line 60 | Line 306 | free_BSDF(             /* free BSDF data structure */
306   {
307          if (b == NULL)
308                  return;
309 <        free(b->inc_dir);
310 <        free(b->inc_rad);
65 <        free(b->out_dir);
66 <        free(b->out_rad);
67 <        free(b->bsdf);
309 >        if (b->bsdf != NULL)
310 >                free(b->bsdf);
311          free(b);
312   }
313  
314  
315 < void
315 > int
316   r_BSDF_incvec(          /* compute random input vector at given location */
317          FVECT v,
318          struct BSDF_data *b,
# Line 82 | Line 325 | r_BSDF_incvec(         /* compute random input vector at give
325          double  rad;
326          int     j;
327          
328 <        getBSDF_incvec(v, b, i);
329 <        rad = getBSDF_incrad(b, i);
328 >        if (!getBSDF_incvec(v, b, i))
329 >                return(0);
330 >        rad = sqrt(getBSDF_incohm(b, i) / PI);
331          multisamp(pert, 3, rv);
332          for (j = 0; j < 3; j++)
333                  v[j] += rad*(2.*pert[j] - 1.);
334          if (xm != NULL)
335                  multv3(v, v, xm);
336 <        normalize(v);
336 >        return(normalize(v) != 0.0);
337   }
338  
339  
340 < void
340 > int
341   r_BSDF_outvec(          /* compute random output vector at given location */
342          FVECT v,
343          struct BSDF_data *b,
# Line 106 | Line 350 | r_BSDF_outvec(         /* compute random output vector at giv
350          double  rad;
351          int     j;
352          
353 <        getBSDF_outvec(v, b, o);
354 <        rad = getBSDF_outrad(b, o);
353 >        if (!getBSDF_outvec(v, b, o))
354 >                return(0);
355 >        rad = sqrt(getBSDF_outohm(b, o) / PI);
356          multisamp(pert, 3, rv);
357          for (j = 0; j < 3; j++)
358                  v[j] += rad*(2.*pert[j] - 1.);
359          if (xm != NULL)
360                  multv3(v, v, xm);
361 <        normalize(v);
361 >        return(normalize(v) != 0.0);
362   }
363  
364  
# Line 156 | Line 401 | addrot(                        /* compute rotation (x,y,z) => (xp,yp,zp) */
401  
402  
403   int
404 < getBSDF_xfm(            /* compute transform for the given surface */
404 > getBSDF_xfm(            /* compute BSDF orient. -> world orient. transform */
405          MAT4 xm,
406          FVECT nrm,
407          UpDir ud
# Line 211 | Line 456 | redistribute(          /* pass distarr ray sums through BSDF *
456          MAT4 xm
457   )
458   {
459 <        MAT4    mymat;
460 <        COLORV  *outarr;
461 <        float   *inpcoef;
459 >        int     nout = 0;
460 >        MAT4    mymat, inmat;
461 >        COLORV  *idist;
462          COLORV  *cp, *csum;
218 –        uint16  *distcnt;
463          FVECT   dv;
464 <        double  oom, wt;
465 <        int     i, j, o;
466 <        int     cnt;
467 <        COLOR   col;
468 <                                        /* allocate temporary memory */
469 <        outarr = (COLORV *)malloc(b->nout * sizeof(COLOR));
470 <        distcnt = (uint16 *)calloc(nalt*nazi, sizeof(uint16));
471 <        inpcoef = (float *)malloc(b->ninc * sizeof(float));
228 <        if ((outarr == NULL) | (distcnt == NULL) | (inpcoef == NULL))
464 >        double  wt;
465 >        int     i, j, k, o;
466 >        COLOR   col, cinc;
467 >                                        /* copy incoming distribution */
468 >        if (b->ninc != distsiz)
469 >                error(INTERNAL, "error 1 in redistribute");
470 >        idist = (COLORV *)malloc(sizeof(COLOR)*distsiz);
471 >        if (idist == NULL)
472                  error(SYSTEM, "out of memory in redistribute");
473 <                                        /* compose matrix */
473 >        memcpy(idist, distarr, sizeof(COLOR)*distsiz);
474 >                                        /* compose direction transform */
475          for (i = 3; i--; ) {
476                  mymat[i][0] = u[i];
477                  mymat[i][1] = v[i];
# Line 245 | Line 489 | redistribute(          /* pass distarr ray sums through BSDF *
489                  for (j = 3; j--; )
490                          mymat[j][i] *= wt;
491          }
492 <                                        /* pass through BSDF */
493 <        for (i = b->ninc; i--; ) {              /* get input coefficients */
250 <                getBSDF_incvec(dv, b, i);
251 <                multv3(dv, dv, mymat);
252 <                wt = getBSDF_incrad(b, i);
253 <                inpcoef[i] = PI*wt*wt * dv[2];  /* solid_angle*cosine(theta) */
254 <        }
255 <        for (o = b->nout; o--; ) {
256 <                csum = &outarr[3*o];
257 <                setcolor(csum, 0., 0., 0.);
258 <                oom = getBSDF_outrad(b, o);
259 <                oom *= oom * PI;
260 <                for (i = b->ninc; i--; ) {
261 <                        wt = BSDF_data(b,i,o) * inpcoef[i] / oom;
262 <                        cp = &distarr[3*i];
263 <                        copycolor(col, cp);
264 <                        scalecolor(col, wt);
265 <                        addcolor(csum, col);
266 <                }
267 <                wt = 1./b->ninc;
268 <                scalecolor(csum, wt);
269 <        }
270 <        free(inpcoef);
492 >        if (!invmat4(inmat, mymat))     /* need inverse as well */
493 >                error(INTERNAL, "cannot invert BSDF transform");
494          newdist(nalt*nazi);             /* resample distribution */
495 <        for (o = b->nout; o--; ) {
496 <                getBSDF_outvec(dv, b, o);
495 >        for (i = b->ninc; i--; ) {
496 >                getBSDF_incvec(dv, b, i);       /* compute incident irrad. */
497                  multv3(dv, dv, mymat);
498 <                j = (.5 + atan2(dv[1],dv[0])*(.5/PI))*nazi + .5;
499 <                if (j >= nazi) j = 0;
500 <                i = (0.9999 - dv[2]*dv[2])*nalt;
501 <                csum = &distarr[3*(i*nazi + j)];
502 <                cp = &outarr[3*o];
503 <                addcolor(csum, cp);
504 <                ++distcnt[i*nazi + j];
505 <        }
506 <        free(outarr);
507 <                                        /* fill in missing bits */
508 <        for (i = nalt; i--; )
509 <            for (j = nazi; j--; ) {
510 <                int     ii, jj, alt, azi;
511 <                if (distcnt[i*nazi + j])
289 <                        continue;
290 <                csum = &distarr[3*(i*nazi + j)];
291 <                setcolor(csum, 0., 0., 0.);
292 <                cnt = 0;
293 <                for (o = 0; !cnt; o++)
294 <                    for (ii = -o; ii <= o; ii++) {
295 <                        alt = i + ii;
296 <                        if (alt < 0) continue;
297 <                        if (alt >= nalt) break;
298 <                        for (jj = -o; jj <= o; jj++) {
299 <                            if (ii*ii + jj*jj != o*o)
498 >                if (dv[2] < 0.0) dv[2] = -dv[2];
499 >                wt = getBSDF_incohm(b, i);
500 >                wt *= dv[2];                    /* solid_angle*cosine(theta) */
501 >                cp = &idist[3*i];
502 >                copycolor(cinc, cp);
503 >                scalecolor(cinc, wt);
504 >                for (k = nalt; k--; )           /* loop over distribution */
505 >                    for (j = nazi; j--; ) {
506 >                        flatdir(dv, (k + .5)/nalt, (double)j/nazi);
507 >                        multv3(dv, dv, inmat);
508 >                                                /* evaluate BSDF @ outgoing */
509 >                        o = getBSDF_outndx(b, dv);
510 >                        if (o < 0) {
511 >                                nout++;
512                                  continue;
301 –                            azi = j + jj;
302 –                            if (azi >= nazi) azi -= nazi;
303 –                            else if (azi < 0) azi += nazi;
304 –                            if (!distcnt[alt*nazi + azi])
305 –                                continue;
306 –                            cp = &distarr[3*(alt*nazi + azi)];
307 –                            addcolor(csum, cp);
308 –                            cnt += distcnt[alt*nazi + azi];
513                          }
514 +                        wt = BSDF_value(b, i, o);
515 +                        copycolor(col, cinc);
516 +                        scalecolor(col, wt);
517 +                        csum = &distarr[3*(k*nazi + j)];
518 +                        addcolor(csum, col);    /* sum into distribution */
519                      }
520 <                wt = 1./cnt;
521 <                scalecolor(csum, wt);
522 <            }
523 <                                        /* finish averages */
524 <        for (i = nalt; i--; )
525 <            for (j = nazi; j--; ) {
526 <                if ((cnt = distcnt[i*nazi + j]) <= 1)
318 <                        continue;
319 <                csum = &distarr[3*(i*nazi + j)];
320 <                wt = 1./cnt;
321 <                scalecolor(csum, wt);
322 <            }
323 <        free(distcnt);
520 >        }
521 >        free(idist);                    /* free temp space */
522 >        if (nout) {
523 >                sprintf(errmsg, "missing %.1f%% of BSDF directions",
524 >                                100.*nout/(b->ninc*nalt*nazi));
525 >                error(WARNING, errmsg);
526 >        }
527   }

Diff Legend

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