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

Comparing ray/src/common/bsdf_m.c (file contents):
Revision 3.7 by greg, Wed Feb 23 21:58:31 2011 UTC vs.
Revision 3.14 by greg, Mon Apr 25 15:48:05 2011 UTC

# Line 81 | Line 81 | static int     nabases = 3;    /* current number of defined b
81   static int
82   fequal(double a, double b)
83   {
84 <        if (b != .0)
84 >        if (b != 0)
85                  a = a/b - 1.;
86          return (a <= 1e-6) & (a >= -1e-6);
87   }
88  
89 < /* returns the name of the given tag */
89 > /* Returns the name of the given tag */
90   #ifdef ezxml_name
91   #undef ezxml_name
92   static char *
# Line 98 | Line 98 | ezxml_name(ezxml_t xml)
98   }
99   #endif
100  
101 < /* returns the given tag's character content or empty string if none */
101 > /* Returns the given tag's character content or empty string if none */
102   #ifdef ezxml_txt
103   #undef ezxml_txt
104   static char *
# Line 157 | Line 157 | SDnewMatrix(int ni, int no)
157   /* Free a BSDF matrix */
158   #define SDfreeMatrix            free
159  
160 < /* get vector for this angle basis index */
160 > /* get vector for this angle basis index (front exiting) */
161   static int
162 < ab_getvec(FVECT v, int ndx, double randX, void *p)
162 > fo_getvec(FVECT v, double ndxr, void *p)
163   {
164 <        ANGLE_BASIS  *ab = (ANGLE_BASIS *)p;
164 >        ANGLE_BASIS     *ab = (ANGLE_BASIS *)p;
165 >        int             ndx = (int)ndxr;
166 >        double          randX = ndxr - ndx;
167          double          rx[2];
168          int             li;
169          double          pol, azi, d;
170          
171 <        if ((ndx < 0) | (ndx >= ab->nangles))
171 >        if ((ndxr < 0) | (ndx >= ab->nangles))
172                  return RC_FAIL;
173          for (li = 0; ndx >= ab->lat[li].nphis; li++)
174                  ndx -= ab->lat[li].nphis;
# Line 181 | Line 183 | ab_getvec(FVECT v, int ndx, double randX, void *p)
183          return RC_GOOD;
184   }
185  
186 < /* get index corresponding to the given vector */
186 > /* get index corresponding to the given vector (front exiting) */
187   static int
188 < ab_getndx(const FVECT v, void *p)
188 > fo_getndx(const FVECT v, void *p)
189   {
190 <        ANGLE_BASIS  *ab = (ANGLE_BASIS *)p;
190 >        ANGLE_BASIS     *ab = (ANGLE_BASIS *)p;
191          int     li, ndx;
192          double  pol, azi, d;
193  
194          if (v == NULL)
195                  return -1;
196 <        if ((v[2] < .0) | (v[2] > 1.0))
196 >        if ((v[2] < 0) | (v[2] > 1.))
197                  return -1;
198          pol = 180.0/M_PI*acos(v[2]);
199          azi = 180.0/M_PI*atan2(v[1], v[0]);
# Line 210 | Line 212 | ab_getndx(const FVECT v, void *p)
212   /* compute square of real value */
213   static double sq(double x) { return x*x; }
214  
215 < /* get projected solid angle for this angle basis index */
215 > /* get projected solid angle for this angle basis index (universal) */
216   static double
217 < ab_getohm(int ndx, void *p)
217 > io_getohm(int ndx, void *p)
218   {
219          static int      last_li = -1;
220          static double   last_ohm;
# Line 235 | Line 237 | ab_getohm(int ndx, void *p)
237                                  (double)ab->lat[li].nphis;
238   }
239  
240 < /* get reverse vector for this angle basis index */
240 > /* get vector for this angle basis index (back incident) */
241   static int
242 < ab_getvecR(FVECT v, int ndx, double randX, void *p)
242 > bi_getvec(FVECT v, double ndxr, void *p)
243   {
244 <        int     na = (*(ANGLE_BASIS *)p).nangles;
243 <
244 <        if (!ab_getvec(v, ndx, randX, p))
244 >        if (!fo_getvec(v, ndxr, p))
245                  return RC_FAIL;
246  
247          v[0] = -v[0];
# Line 251 | Line 251 | ab_getvecR(FVECT v, int ndx, double randX, void *p)
251          return RC_GOOD;
252   }
253  
254 < /* get index corresponding to the reverse vector */
254 > /* get index corresponding to the vector (back incident) */
255   static int
256 < ab_getndxR(const FVECT v, void *p)
256 > bi_getndx(const FVECT v, void *p)
257   {
258          FVECT  v2;
259          
# Line 261 | Line 261 | ab_getndxR(const FVECT v, void *p)
261          v2[1] = -v[1];
262          v2[2] = -v[2];
263  
264 <        return ab_getndx(v2, p);
264 >        return fo_getndx(v2, p);
265   }
266  
267 + /* get vector for this angle basis index (back exiting) */
268 + static int
269 + bo_getvec(FVECT v, double ndxr, void *p)
270 + {
271 +        if (!fo_getvec(v, ndxr, p))
272 +                return RC_FAIL;
273 +
274 +        v[2] = -v[2];
275 +
276 +        return RC_GOOD;
277 + }
278 +
279 + /* get index corresponding to the vector (back exiting) */
280 + static int
281 + bo_getndx(const FVECT v, void *p)
282 + {
283 +        FVECT  v2;
284 +        
285 +        v2[0] = v[0];
286 +        v2[1] = v[1];
287 +        v2[2] = -v[2];
288 +
289 +        return fo_getndx(v2, p);
290 + }
291 +
292 + /* get vector for this angle basis index (front incident) */
293 + static int
294 + fi_getvec(FVECT v, double ndxr, void *p)
295 + {
296 +        if (!fo_getvec(v, ndxr, p))
297 +                return RC_FAIL;
298 +
299 +        v[0] = -v[0];
300 +        v[1] = -v[1];
301 +
302 +        return RC_GOOD;
303 + }
304 +
305 + /* get index corresponding to the vector (front incident) */
306 + static int
307 + fi_getndx(const FVECT v, void *p)
308 + {
309 +        FVECT  v2;
310 +        
311 +        v2[0] = -v[0];
312 +        v2[1] = -v[1];
313 +        v2[2] = v[2];
314 +
315 +        return fo_getndx(v2, p);
316 + }
317 +
318   /* load custom BSDF angle basis */
319   static int
320   load_angle_basis(ezxml_t wab)
# Line 301 | Line 352 | load_angle_basis(ezxml_t wab)
352                                          "ThetaBounds"), "LowerTheta"))),
353                                  abase_list[nabases].lat[i].tmin)) {
354                          sprintf(SDerrorDetail, "Theta values disagree in '%s'",
355 <                                abname);
355 >                                        abname);
356                          return RC_DATERR;
357                  }
358                  abase_list[nabases].nangles +=
# Line 311 | Line 362 | load_angle_basis(ezxml_t wab)
362                                  (abase_list[nabases].lat[i].nphis == 1 &&
363                                  abase_list[nabases].lat[i].tmin > FTINY)) {
364                          sprintf(SDerrorDetail, "Illegal phi count in '%s'",
365 <                                abname);
365 >                                        abname);
366                          return RC_DATERR;
367                  }
368          }
# Line 362 | Line 413 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
413          SDSpectralDF    *df;
414          SDMat           *dp;
415          char            *sdata;
416 <        int             tback;
416 >        int             tfront;
417          int             inbi, outbi;
418          int             i;
419                                          /* allocate BSDF component */
420          sdata = ezxml_txt(ezxml_child(wdb, "WavelengthDataDirection"));
421 <        if ((tback = !strcasecmp(sdata, "Transmission Back")) ||
422 <                        (sd->tf == NULL &&
423 <                                !strcasecmp(sdata, "Transmission Front"))) {
421 >        /*
422 >         * Remember that front and back are reversed from WINDOW 6 orientations
423 >         * Favor their "Front" (incoming light) since that's more often valid
424 >         */
425 >        tfront = !strcasecmp(sdata, "Transmission Back");
426 >        if (!strcasecmp(sdata, "Transmission Front") ||
427 >                        tfront & (sd->tf == NULL)) {
428                  if (sd->tf != NULL)
429                          SDfreeSpectralDF(sd->tf);
430                  if ((sd->tf = SDnewSpectralDF(1)) == NULL)
# Line 424 | Line 479 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
479          dp->ib_priv = &abase_list[inbi];
480          dp->ob_priv = &abase_list[outbi];
481          if (df == sd->tf) {
482 <                if (tback) {
483 <                        dp->ib_vec = &ab_getvecR;
484 <                        dp->ib_ndx = &ab_getndxR;
485 <                        dp->ob_vec = &ab_getvec;
486 <                        dp->ob_ndx = &ab_getndx;
482 >                if (tfront) {
483 >                        dp->ib_vec = &fi_getvec;
484 >                        dp->ib_ndx = &fi_getndx;
485 >                        dp->ob_vec = &bo_getvec;
486 >                        dp->ob_ndx = &bo_getndx;
487                  } else {
488 <                        dp->ib_vec = &ab_getvec;
489 <                        dp->ib_ndx = &ab_getndx;
490 <                        dp->ob_vec = &ab_getvecR;
491 <                        dp->ob_ndx = &ab_getndxR;
488 >                        dp->ib_vec = &bi_getvec;
489 >                        dp->ib_ndx = &bi_getndx;
490 >                        dp->ob_vec = &fo_getvec;
491 >                        dp->ob_ndx = &fo_getndx;
492                  }
493          } else if (df == sd->rf) {
494 <                dp->ib_vec = &ab_getvec;
495 <                dp->ib_ndx = &ab_getndx;
496 <                dp->ob_vec = &ab_getvec;
497 <                dp->ob_ndx = &ab_getndx;
494 >                dp->ib_vec = &fi_getvec;
495 >                dp->ib_ndx = &fi_getndx;
496 >                dp->ob_vec = &fo_getvec;
497 >                dp->ob_ndx = &fo_getndx;
498          } else /* df == sd->rb */ {
499 <                dp->ib_vec = &ab_getvecR;
500 <                dp->ib_ndx = &ab_getndxR;
501 <                dp->ob_vec = &ab_getvecR;
502 <                dp->ob_ndx = &ab_getndxR;
499 >                dp->ib_vec = &bi_getvec;
500 >                dp->ib_ndx = &bi_getndx;
501 >                dp->ob_vec = &bo_getvec;
502 >                dp->ob_ndx = &bo_getndx;
503          }
504 <        dp->ib_ohm = &ab_getohm;
505 <        dp->ob_ohm = &ab_getohm;
504 >        dp->ib_ohm = &io_getohm;
505 >        dp->ob_ohm = &io_getohm;
506          df->comp[0].cspec[0] = c_dfcolor; /* XXX monochrome for now */
507          df->comp[0].dist = dp;
508          df->comp[0].func = &SDhandleMtx;
509                                          /* read BSDF data */
510 <        sdata  = ezxml_txt(ezxml_child(wdb,"ScatteringData"));
510 >        sdata = ezxml_txt(ezxml_child(wdb,"ScatteringData"));
511          if (!sdata || !*sdata) {
512                  sprintf(SDerrorDetail, "Missing BSDF ScatteringData in '%s'",
513                                  sd->name);
# Line 576 | Line 631 | SDloadMtx(SDData *sd, ezxml_t wtl)
631   /* Get Matrix BSDF value */
632   static int
633   SDgetMtxBSDF(float coef[SDmaxCh], const FVECT outVec,
634 <                                const FVECT inVec, const void *dist)
634 >                                const FVECT inVec, SDComponent *sdc)
635   {
636 <        const SDMat     *dp = (const SDMat *)dist;
636 >        const SDMat     *dp;
637          int             i_ndx, o_ndx;
638 +                                        /* check arguments */
639 +        if ((coef == NULL) | (outVec == NULL) | (inVec == NULL) | (sdc == NULL)
640 +                        || (dp = (SDMat *)sdc->dist) == NULL)
641 +                return 0;
642                                          /* get angle indices */
643          i_ndx = mBSDF_incndx(dp, inVec);
644          o_ndx = mBSDF_outndx(dp, outVec);
# Line 594 | Line 653 | SDgetMtxBSDF(float coef[SDmaxCh], const FVECT outVec,
653          return 1;                       /* XXX monochrome for now */
654   }
655  
656 < /* Query solid angle for vector */
656 > /* Query solid angle for vector(s) */
657   static SDError
658 < SDqueryMtxProjSA(double *psa, const FVECT vec, int qflags, const void *dist)
658 > SDqueryMtxProjSA(double *psa, const FVECT v1, const RREAL *v2,
659 >                                        int qflags, SDComponent *sdc)
660   {
661 <        const SDMat     *dp = (const SDMat *)dist;
661 >        const SDMat     *dp;
662          double          inc_psa, out_psa;
663                                          /* check arguments */
664 <        if ((psa == NULL) | (vec == NULL) | (dp == NULL))
664 >        if ((psa == NULL) | (v1 == NULL) | (sdc == NULL) ||
665 >                        (dp = (SDMat *)sdc->dist) == NULL)
666                  return SDEargument;
667 +        if (v2 == NULL)
668 +                v2 = v1;
669                                          /* get projected solid angles */
670 <        inc_psa = mBSDF_incohm(dp, mBSDF_incndx(dp, vec));
671 <        out_psa = mBSDF_outohm(dp, mBSDF_outndx(dp, vec));
670 >        out_psa = mBSDF_outohm(dp, mBSDF_outndx(dp, v1));
671 >        inc_psa = mBSDF_incohm(dp, mBSDF_incndx(dp, v2));
672 >        if ((v1 != v2) & (out_psa <= 0) & (inc_psa <= 0)) {
673 >                inc_psa = mBSDF_outohm(dp, mBSDF_outndx(dp, v2));
674 >                out_psa = mBSDF_incohm(dp, mBSDF_incndx(dp, v1));
675 >        }
676  
677          switch (qflags) {               /* record based on flag settings */
611 –        case SDqueryVal:
612 –                psa[0] = .0;
613 –                /* fall through */
678          case SDqueryMax:
679                  if (inc_psa > psa[0])
680                          psa[0] = inc_psa;
# Line 618 | Line 682 | SDqueryMtxProjSA(double *psa, const FVECT vec, int qfl
682                          psa[0] = out_psa;
683                  break;
684          case SDqueryMin+SDqueryMax:
685 <                if (inc_psa > psa[0])
685 >                if (inc_psa > psa[1])
686                          psa[1] = inc_psa;
687 <                if (out_psa > psa[0])
687 >                if (out_psa > psa[1])
688                          psa[1] = out_psa;
689                  /* fall through */
690 +        case SDqueryVal:
691 +                if (qflags == SDqueryVal)
692 +                        psa[0] = M_PI;
693 +                /* fall through */
694          case SDqueryMin:
695 <                if ((inc_psa > .0) & (inc_psa < psa[0]))
695 >                if ((inc_psa > 0) & (inc_psa < psa[0]))
696                          psa[0] = inc_psa;
697 <                if ((out_psa > .0) & (out_psa < psa[0]))
697 >                if ((out_psa > 0) & (out_psa < psa[0]))
698                          psa[0] = out_psa;
699                  break;
700          }
701                                          /* make sure it's legal */
702 <        return (psa[0] <= .0) ? SDEinternal : SDEnone;
702 >        return (psa[0] <= 0) ? SDEinternal : SDEnone;
703   }
704  
705   /* Compute new cumulative distribution from BSDF */
# Line 669 | Line 737 | make_cdist(SDMatCDst *cd, const FVECT inVec, SDMat *dp
737   static const SDCDst *
738   SDgetMtxCDist(const FVECT inVec, SDComponent *sdc)
739   {
740 <        SDMat           *dp = (SDMat *)sdc->dist;
740 >        SDMat           *dp;
741          int             reverse;
742          SDMatCDst       myCD;
743          SDMatCDst       *cd, *cdlast;
744                                          /* check arguments */
745 <        if ((inVec == NULL) | (dp == NULL))
745 >        if ((inVec == NULL) | (sdc == NULL) ||
746 >                        (dp = (SDMat *)sdc->dist) == NULL)
747                  return NULL;
748          memset(&myCD, 0, sizeof(myCD));
749          myCD.indx = mBSDF_incndx(dp, inVec);
# Line 693 | Line 762 | SDgetMtxCDist(const FVECT inVec, SDComponent *sdc)
762                  reverse = 1;
763          }
764          cdlast = NULL;                  /* check for it in cache list */
765 <        for (cd = (SDMatCDst *)sdc->cdList;
766 <                                cd != NULL; cd = (SDMatCDst *)cd->next) {
765 >        for (cd = (SDMatCDst *)sdc->cdList; cd != NULL;
766 >                                cdlast = cd, cd = (SDMatCDst *)cd->next)
767                  if (cd->indx == myCD.indx && (cd->calen == myCD.calen) &
768                                          (cd->ob_priv == myCD.ob_priv) &
769                                          (cd->ob_vec == myCD.ob_vec))
770                          break;
702 –                cdlast = cd;
703 –        }
771          if (cd == NULL) {               /* need to allocate new entry */
772                  cd = (SDMatCDst *)malloc(sizeof(SDMatCDst) +
773 <                                        myCD.calen*sizeof(myCD.carr[0]));
773 >                                        sizeof(myCD.carr[0])*myCD.calen);
774                  if (cd == NULL)
775                          return NULL;
776                  *cd = myCD;             /* compute cumulative distribution */
# Line 723 | Line 790 | SDgetMtxCDist(const FVECT inVec, SDComponent *sdc)
790  
791   /* Sample cumulative distribution */
792   static SDError
793 < SDsampMtxCDist(FVECT outVec, double randX, const SDCDst *cdp)
793 > SDsampMtxCDist(FVECT ioVec, double randX, const SDCDst *cdp)
794   {
795          const unsigned  maxval = ~0;
796          const SDMatCDst *mcd = (const SDMatCDst *)cdp;
797          const unsigned  target = randX*maxval;
798          int             i, iupper, ilower;
799                                          /* check arguments */
800 <        if ((outVec == NULL) | (mcd == NULL))
800 >        if ((ioVec == NULL) | (mcd == NULL))
801                  return SDEargument;
802                                          /* binary search to find index */
803          ilower = 0; iupper = mcd->calen;
# Line 743 | Line 810 | SDsampMtxCDist(FVECT outVec, double randX, const SDCDs
810          randX = (randX*maxval - mcd->carr[ilower]) /
811                          (double)(mcd->carr[iupper] - mcd->carr[ilower]);
812                                          /* convert index to vector */
813 <        if ((*mcd->ob_vec)(outVec, i, randX, mcd->ob_priv))
813 >        if ((*mcd->ob_vec)(ioVec, i+randX, mcd->ob_priv))
814                  return SDEnone;
815 <        strcpy(SDerrorDetail, "BSDF sampling fault");
815 >        strcpy(SDerrorDetail, "Matrix BSDF sampling fault");
816          return SDEinternal;
817   }
818  

Diff Legend

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