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.3 by greg, Fri Feb 18 02:41:55 2011 UTC vs.
Revision 3.7 by greg, Wed Feb 23 21:58:31 2011 UTC

# Line 19 | Line 19 | static const char RCSid[] = "$Id$";
19   #include "bsdf.h"
20   #include "bsdf_m.h"
21  
22 – #ifndef FTINY
23 – #define FTINY           1e-6
24 – #endif
25 –
22   /* Function return codes */
23   #define RC_GOOD         1
24   #define RC_FAIL         0
# Line 350 | Line 346 | get_extrema(SDSpectralDF *df)
346          }
347          free(ohma);
348                                          /* need incoming solid angles, too? */
349 <        if (dp->ninc < dp->nout || dp->ib_ohm != dp->ob_ohm ||
354 <                                dp->ib_priv != dp->ob_priv) {
349 >        if ((dp->ib_ohm != dp->ob_ohm) | (dp->ib_priv != dp->ob_priv)) {
350                  double  ohm;
351                  for (i = dp->ninc; i--; )
352                          if ((ohm = mBSDF_incohm(dp,i)) < df->minProjSA)
# Line 364 | Line 359 | get_extrema(SDSpectralDF *df)
359   static int
360   load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
361   {
367 –        char            *cbasis = ezxml_txt(ezxml_child(wdb,"ColumnAngleBasis"));
368 –        char            *rbasis = ezxml_txt(ezxml_child(wdb,"RowAngleBasis"));
362          SDSpectralDF    *df;
363          SDMat           *dp;
364          char            *sdata;
365 +        int             tback;
366          int             inbi, outbi;
367          int             i;
374 –
375 –        if ((!cbasis || !*cbasis) | (!rbasis || !*rbasis)) {
376 –                sprintf(SDerrorDetail, "Missing column/row basis for BSDF '%s'",
377 –                                sd->name);
378 –                return RC_FORMERR;
379 –        }
368                                          /* allocate BSDF component */
369          sdata = ezxml_txt(ezxml_child(wdb, "WavelengthDataDirection"));
370 <        if (!strcasecmp(sdata, "Transmission Front")) {
370 >        if ((tback = !strcasecmp(sdata, "Transmission Back")) ||
371 >                        (sd->tf == NULL &&
372 >                                !strcasecmp(sdata, "Transmission Front"))) {
373                  if (sd->tf != NULL)
374                          SDfreeSpectralDF(sd->tf);
375                  if ((sd->tf = SDnewSpectralDF(1)) == NULL)
376                          return RC_MEMERR;
377                  df = sd->tf;
378          } else if (!strcasecmp(sdata, "Reflection Front")) {
379 <                if (sd->rf != NULL)
390 <                        SDfreeSpectralDF(sd->rf);
391 <                if ((sd->rf = SDnewSpectralDF(1)) == NULL)
392 <                        return RC_MEMERR;
393 <                df = sd->rf;
394 <        } else if (!strcasecmp(sdata, "Reflection Back")) {
395 <                if (sd->rb != NULL)
379 >                if (sd->rb != NULL)     /* note back-front reversal */
380                          SDfreeSpectralDF(sd->rb);
381                  if ((sd->rb = SDnewSpectralDF(1)) == NULL)
382                          return RC_MEMERR;
383                  df = sd->rb;
384 +        } else if (!strcasecmp(sdata, "Reflection Back")) {
385 +                if (sd->rf != NULL)     /* note front-back reversal */
386 +                        SDfreeSpectralDF(sd->rf);
387 +                if ((sd->rf = SDnewSpectralDF(1)) == NULL)
388 +                        return RC_MEMERR;
389 +                df = sd->rf;
390          } else
391                  return RC_FAIL;
392 +        /* XXX should also check "ScatteringDataType" for consistency? */
393                                          /* get angle bases */
394          sdata = ezxml_txt(ezxml_child(wdb,"ColumnAngleBasis"));
395          if (!sdata || !*sdata) {
# Line 407 | Line 398 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
398                  return RC_FORMERR;
399          }
400          for (inbi = nabases; inbi--; )
401 <                if (!strcasecmp(cbasis, abase_list[inbi].name))
401 >                if (!strcasecmp(sdata, abase_list[inbi].name))
402                          break;
403          if (inbi < 0) {
404 <                sprintf(SDerrorDetail, "Undefined ColumnAngleBasis '%s'",
414 <                                cbasis);
404 >                sprintf(SDerrorDetail, "Undefined ColumnAngleBasis '%s'", sdata);
405                  return RC_FORMERR;
406          }
407          sdata = ezxml_txt(ezxml_child(wdb,"RowAngleBasis"));
# Line 421 | Line 411 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
411                  return RC_FORMERR;
412          }
413          for (outbi = nabases; outbi--; )
414 <                if (!strcasecmp(rbasis, abase_list[outbi].name))
414 >                if (!strcasecmp(sdata, abase_list[outbi].name))
415                          break;
416          if (outbi < 0) {
417 <                sprintf(SDerrorDetail, "Undefined RowAngleBasis '%s'", cbasis);
417 >                sprintf(SDerrorDetail, "Undefined RowAngleBasis '%s'", sdata);
418                  return RC_FORMERR;
419          }
420                                          /* allocate BSDF matrix */
421          dp = SDnewMatrix(abase_list[inbi].nangles, abase_list[outbi].nangles);
422          if (dp == NULL)
423                  return RC_MEMERR;
424 <        dp->ib_priv = (void *)&abase_list[inbi];
425 <        dp->ob_priv = (void *)&abase_list[outbi];
424 >        dp->ib_priv = &abase_list[inbi];
425 >        dp->ob_priv = &abase_list[outbi];
426          if (df == sd->tf) {
427 <                dp->ib_vec = ab_getvecR;
428 <                dp->ib_ndx = ab_getndxR;
429 <                dp->ob_vec = ab_getvec;
430 <                dp->ob_ndx = ab_getndx;
427 >                if (tback) {
428 >                        dp->ib_vec = &ab_getvecR;
429 >                        dp->ib_ndx = &ab_getndxR;
430 >                        dp->ob_vec = &ab_getvec;
431 >                        dp->ob_ndx = &ab_getndx;
432 >                } else {
433 >                        dp->ib_vec = &ab_getvec;
434 >                        dp->ib_ndx = &ab_getndx;
435 >                        dp->ob_vec = &ab_getvecR;
436 >                        dp->ob_ndx = &ab_getndxR;
437 >                }
438          } else if (df == sd->rf) {
439 <                dp->ib_vec = ab_getvec;
440 <                dp->ib_ndx = ab_getndx;
441 <                dp->ob_vec = ab_getvec;
442 <                dp->ob_ndx = ab_getndx;
439 >                dp->ib_vec = &ab_getvec;
440 >                dp->ib_ndx = &ab_getndx;
441 >                dp->ob_vec = &ab_getvec;
442 >                dp->ob_ndx = &ab_getndx;
443          } else /* df == sd->rb */ {
444 <                dp->ib_vec = ab_getvecR;
445 <                dp->ib_ndx = ab_getndxR;
446 <                dp->ob_vec = ab_getvecR;
447 <                dp->ob_ndx = ab_getndxR;
444 >                dp->ib_vec = &ab_getvecR;
445 >                dp->ib_ndx = &ab_getndxR;
446 >                dp->ob_vec = &ab_getvecR;
447 >                dp->ob_ndx = &ab_getndxR;
448          }
449 <        dp->ib_ohm = ab_getohm;
450 <        dp->ob_ohm = ab_getohm;
449 >        dp->ib_ohm = &ab_getohm;
450 >        dp->ob_ohm = &ab_getohm;
451          df->comp[0].cspec[0] = c_dfcolor; /* XXX monochrome for now */
452          df->comp[0].dist = dp;
453          df->comp[0].func = &SDhandleMtx;
# Line 519 | Line 516 | extract_diffuse(SDValue *dv, SDSpectralDF *df)
516                  c_cmix(&dv->spec, dv->cieY, &dv->spec, ymin, &df->comp[n].cspec[0]);
517                  dv->cieY += ymin;
518          }
519 <        df->maxHemi -= dv->cieY;        /* correct minimum hemispherical */
520 <        dv->spec.clock++;               /* make sure everything is set */
519 >        df->maxHemi -= dv->cieY;        /* adjust minimum hemispherical */
520 >                                        /* make sure everything is set */
521          c_ccvt(&dv->spec, C_CSXY+C_CSSPEC);
522   }
523  
524   /* Load a BSDF matrix from an open XML file */
525   SDError
526 < SDloadMtx(SDData *sd, ezxml_t fl)
526 > SDloadMtx(SDData *sd, ezxml_t wtl)
527   {
528 <        ezxml_t                 wtl, wld, wdb;
528 >        ezxml_t                 wld, wdb;
529          int                     rowIn;
530          struct BSDF_data        *dp;
531          char                    *txt;
532          int                     rval;
533          
534 <        if (strcmp(ezxml_name(fl), "WindowElement")) {
534 >        txt = ezxml_txt(ezxml_child(ezxml_child(wtl,
535 >                        "DataDefinition"), "IncidentDataStructure"));
536 >        if (txt == NULL || !*txt) {
537                  sprintf(SDerrorDetail,
538 <                        "BSDF \"%s\": top level node not 'WindowElement'",
538 >                        "BSDF \"%s\": missing IncidentDataStructure",
539                                  sd->name);
540                  return SDEformat;
541          }
543 –        wtl = ezxml_child(ezxml_child(fl, "Optical"), "Layer");
544 –        txt = ezxml_txt(ezxml_child(ezxml_child(wtl,
545 –                        "DataDefinition"), "IncidentDataStructure"));
542          if (!strcasecmp(txt, "Rows"))
543                  rowIn = 1;
544          else if (!strcasecmp(txt, "Columns"))
# Line 557 | Line 553 | SDloadMtx(SDData *sd, ezxml_t fl)
553          rval = load_angle_basis(ezxml_child(ezxml_child(wtl,
554                                  "DataDefinition"), "AngleBasis"));
555          if (rval < 0)
556 <                goto err_return;
556 >                return convert_errcode(rval);
557                                  /* load BSDF components */
558          for (wld = ezxml_child(wtl, "WavelengthData");
559                                  wld != NULL; wld = wld->next) {
# Line 567 | Line 563 | SDloadMtx(SDData *sd, ezxml_t fl)
563                  for (wdb = ezxml_child(wld, "WavelengthDataBlock");
564                                          wdb != NULL; wdb = wdb->next)
565                          if ((rval = load_bsdf_data(sd, wdb, rowIn)) < 0)
566 <                                goto err_return;
566 >                                return convert_errcode(rval);
567          }
568                                  /* separate diffuse components */
569          extract_diffuse(&sd->rLambFront, sd->rf);
# Line 575 | Line 571 | SDloadMtx(SDData *sd, ezxml_t fl)
571          extract_diffuse(&sd->tLamb, sd->tf);
572                                  /* return success */
573          return SDEnone;
578 – err_return:                     /* jump here on failure */
579 –        if (sd->rf != NULL) {
580 –                SDfreeSpectralDF(sd->rf);
581 –                sd->rf = NULL;
582 –        }
583 –        if (sd->rb != NULL) {
584 –                SDfreeSpectralDF(sd->rb);
585 –                sd->rb = NULL;
586 –        }
587 –        if (sd->tf != NULL) {
588 –                SDfreeSpectralDF(sd->tf);
589 –                sd->tf = NULL;
590 –        }
591 –        return convert_errcode(rval);
574   }
575  
576   /* Get Matrix BSDF value */
# Line 617 | Line 599 | static SDError
599   SDqueryMtxProjSA(double *psa, const FVECT vec, int qflags, const void *dist)
600   {
601          const SDMat     *dp = (const SDMat *)dist;
602 <
603 <        if (!(qflags & SDqueryInc+SDqueryOut))
602 >        double          inc_psa, out_psa;
603 >                                        /* check arguments */
604 >        if ((psa == NULL) | (vec == NULL) | (dp == NULL))
605                  return SDEargument;
606 <        if (qflags & SDqueryInc) {
607 <                double  inc_psa = mBSDF_incohm(dp, mBSDF_incndx(dp, vec));
608 <                if (inc_psa < .0)
609 <                        return SDEinternal;
610 <                switch (qflags & SDqueryMin+SDqueryMax) {
611 <                case SDqueryMax:
612 <                        if (inc_psa > psa[0])
613 <                                psa[0] = inc_psa;
614 <                        break;
615 <                case SDqueryMin+SDqueryMax:
633 <                        if (inc_psa > psa[1])
634 <                                psa[1] = inc_psa;
635 <                        /* fall through */
636 <                case SDqueryMin:
637 <                        if (inc_psa < psa[0])
638 <                                psa[0] = inc_psa;
639 <                        break;
640 <                case 0:
606 >                                        /* get projected solid angles */
607 >        inc_psa = mBSDF_incohm(dp, mBSDF_incndx(dp, vec));
608 >        out_psa = mBSDF_outohm(dp, mBSDF_outndx(dp, vec));
609 >
610 >        switch (qflags) {               /* record based on flag settings */
611 >        case SDqueryVal:
612 >                psa[0] = .0;
613 >                /* fall through */
614 >        case SDqueryMax:
615 >                if (inc_psa > psa[0])
616                          psa[0] = inc_psa;
617 <                        break;
618 <                }
617 >                if (out_psa > psa[0])
618 >                        psa[0] = out_psa;
619 >                break;
620 >        case SDqueryMin+SDqueryMax:
621 >                if (inc_psa > psa[0])
622 >                        psa[1] = inc_psa;
623 >                if (out_psa > psa[0])
624 >                        psa[1] = out_psa;
625 >                /* fall through */
626 >        case SDqueryMin:
627 >                if ((inc_psa > .0) & (inc_psa < psa[0]))
628 >                        psa[0] = inc_psa;
629 >                if ((out_psa > .0) & (out_psa < psa[0]))
630 >                        psa[0] = out_psa;
631 >                break;
632          }
633 <        if (qflags & SDqueryOut) {
634 <                double  out_psa = mBSDF_outohm(dp, mBSDF_outndx(dp, vec));
647 <                if (out_psa < .0)
648 <                        return SDEinternal;
649 <                switch (qflags & SDqueryMin+SDqueryMax) {
650 <                case SDqueryMax:
651 <                        if (out_psa > psa[0])
652 <                                psa[0] = out_psa;
653 <                        break;
654 <                case SDqueryMin+SDqueryMax:
655 <                        if (out_psa > psa[1])
656 <                                psa[1] = out_psa;
657 <                        /* fall through */
658 <                case SDqueryMin:
659 <                        if (out_psa < psa[0])
660 <                                psa[0] = out_psa;
661 <                        break;
662 <                case 0:
663 <                        psa[(qflags&SDqueryInc)!=0] = out_psa;
664 <                        break;
665 <                }
666 <        }
667 <        return SDEnone;
633 >                                        /* make sure it's legal */
634 >        return (psa[0] <= .0) ? SDEinternal : SDEnone;
635   }
636  
637   /* Compute new cumulative distribution from BSDF */
# Line 706 | Line 673 | SDgetMtxCDist(const FVECT inVec, SDComponent *sdc)
673          int             reverse;
674          SDMatCDst       myCD;
675          SDMatCDst       *cd, *cdlast;
676 <
677 <        if (dp == NULL)
676 >                                        /* check arguments */
677 >        if ((inVec == NULL) | (dp == NULL))
678                  return NULL;
679          memset(&myCD, 0, sizeof(myCD));
680          myCD.indx = mBSDF_incndx(dp, inVec);
# Line 762 | Line 729 | SDsampMtxCDist(FVECT outVec, double randX, const SDCDs
729          const SDMatCDst *mcd = (const SDMatCDst *)cdp;
730          const unsigned  target = randX*maxval;
731          int             i, iupper, ilower;
732 +                                        /* check arguments */
733 +        if ((outVec == NULL) | (mcd == NULL))
734 +                return SDEargument;
735                                          /* binary search to find index */
736          ilower = 0; iupper = mcd->calen;
737          while ((i = (iupper + ilower) >> 1) != ilower)

Diff Legend

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