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.1 by greg, Fri Feb 18 00:40:25 2011 UTC vs.
Revision 3.5 by greg, Sat Feb 19 23:42:09 2011 UTC

# Line 1 | Line 1
1 + #ifndef lint
2 + static const char RCSid[] = "$Id$";
3 + #endif
4   /*
5   *  bsdf_m.c
6   *  
# Line 8 | Line 11
11   *
12   */
13  
14 < #include <stdio.h>
14 > #include "rtio.h"
15   #include <stdlib.h>
16   #include <math.h>
14 – #include <strings.h>
17   #include <ctype.h>
18   #include "ezxml.h"
19   #include "bsdf.h"
20   #include "bsdf_m.h"
21  
20 – #ifndef FTINY
21 – #define FTINY           1e-6
22 – #endif
23 –
22   /* Function return codes */
23   #define RC_GOOD         1
24   #define RC_FAIL         0
# Line 348 | 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 ||
352 <                                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 358 | Line 355 | get_extrema(SDSpectralDF *df)
355          return (df->maxHemi <= 1.01);
356   }
357  
361 – /* skip integer in string */
362 – static char *
363 – i_skip(char  *s)
364 – {
365 –        while (isspace(*s))
366 –                s++;
367 –        if (*s == '-' || *s == '+')
368 –                s++;
369 –        if (!isdigit(*s))
370 –                return(NULL);
371 –        do
372 –                s++;
373 –        while (isdigit(*s));
374 –        return(s);
375 – }
376 –
377 – /* skip float in string */
378 – static char *
379 – f_skip(char  *s)
380 – {
381 –        register char  *cp;
382 –
383 –        while (isspace(*s))
384 –                s++;
385 –        if (*s == '-' || *s == '+')
386 –                s++;
387 –        cp = s;
388 –        while (isdigit(*cp))
389 –                cp++;
390 –        if (*cp == '.') {
391 –                cp++; s++;
392 –                while (isdigit(*cp))
393 –                        cp++;
394 –        }
395 –        if (cp == s)
396 –                return(NULL);
397 –        if (*cp == 'e' || *cp == 'E')
398 –                return(i_skip(cp+1));
399 –        return(cp);
400 – }
401 –
358   /* load BSDF distribution for this wavelength */
359   static int
360   load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
361   {
406 –        char            *cbasis = ezxml_txt(ezxml_child(wdb,"ColumnAngleBasis"));
407 –        char            *rbasis = ezxml_txt(ezxml_child(wdb,"RowAngleBasis"));
362          SDSpectralDF    *df;
363          SDMat           *dp;
364          char            *sdata;
365          int             inbi, outbi;
366          int             i;
413 –
414 –        if ((!cbasis || !*cbasis) | (!rbasis || !*rbasis)) {
415 –                sprintf(SDerrorDetail, "Missing column/row basis for BSDF '%s'",
416 –                                sd->name);
417 –                return RC_FORMERR;
418 –        }
367                                          /* allocate BSDF component */
368          sdata = ezxml_txt(ezxml_child(wdb, "WavelengthDataDirection"));
369          if (!strcasecmp(sdata, "Transmission Front")) {
# Line 438 | Line 386 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
386                  df = sd->rb;
387          } else
388                  return RC_FAIL;
389 +        /* XXX should also check "ScatteringDataType" for consistency? */
390                                          /* get angle bases */
391          sdata = ezxml_txt(ezxml_child(wdb,"ColumnAngleBasis"));
392          if (!sdata || !*sdata) {
# Line 446 | Line 395 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
395                  return RC_FORMERR;
396          }
397          for (inbi = nabases; inbi--; )
398 <                if (!strcasecmp(cbasis, abase_list[inbi].name))
398 >                if (!strcasecmp(sdata, abase_list[inbi].name))
399                          break;
400          if (inbi < 0) {
401 <                sprintf(SDerrorDetail, "Undefined ColumnAngleBasis '%s'",
453 <                                cbasis);
401 >                sprintf(SDerrorDetail, "Undefined ColumnAngleBasis '%s'", sdata);
402                  return RC_FORMERR;
403          }
404          sdata = ezxml_txt(ezxml_child(wdb,"RowAngleBasis"));
# Line 460 | Line 408 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
408                  return RC_FORMERR;
409          }
410          for (outbi = nabases; outbi--; )
411 <                if (!strcasecmp(rbasis, abase_list[outbi].name))
411 >                if (!strcasecmp(sdata, abase_list[outbi].name))
412                          break;
413          if (outbi < 0) {
414 <                sprintf(SDerrorDetail, "Undefined RowAngleBasis '%s'", cbasis);
414 >                sprintf(SDerrorDetail, "Undefined RowAngleBasis '%s'", sdata);
415                  return RC_FORMERR;
416          }
417                                          /* allocate BSDF matrix */
418          dp = SDnewMatrix(abase_list[inbi].nangles, abase_list[outbi].nangles);
419          if (dp == NULL)
420                  return RC_MEMERR;
421 <        dp->ib_priv = (void *)&abase_list[inbi];
422 <        dp->ob_priv = (void *)&abase_list[outbi];
421 >        dp->ib_priv = &abase_list[inbi];
422 >        dp->ob_priv = &abase_list[outbi];
423          if (df == sd->tf) {
424 <                dp->ib_vec = ab_getvecR;
425 <                dp->ib_ndx = ab_getndxR;
426 <                dp->ob_vec = ab_getvec;
427 <                dp->ob_ndx = ab_getndx;
424 >                dp->ib_vec = &ab_getvecR;
425 >                dp->ib_ndx = &ab_getndxR;
426 >                dp->ob_vec = &ab_getvec;
427 >                dp->ob_ndx = &ab_getndx;
428          } else if (df == sd->rf) {
429 <                dp->ib_vec = ab_getvec;
430 <                dp->ib_ndx = ab_getndx;
431 <                dp->ob_vec = ab_getvec;
432 <                dp->ob_ndx = ab_getndx;
429 >                dp->ib_vec = &ab_getvec;
430 >                dp->ib_ndx = &ab_getndx;
431 >                dp->ob_vec = &ab_getvec;
432 >                dp->ob_ndx = &ab_getndx;
433          } else /* df == sd->rb */ {
434 <                dp->ib_vec = ab_getvecR;
435 <                dp->ib_ndx = ab_getndxR;
436 <                dp->ob_vec = ab_getvecR;
437 <                dp->ob_ndx = ab_getndxR;
434 >                dp->ib_vec = &ab_getvecR;
435 >                dp->ib_ndx = &ab_getndxR;
436 >                dp->ob_vec = &ab_getvecR;
437 >                dp->ob_ndx = &ab_getndxR;
438          }
439 <        dp->ib_ohm = ab_getohm;
440 <        dp->ob_ohm = ab_getohm;
439 >        dp->ib_ohm = &ab_getohm;
440 >        dp->ob_ohm = &ab_getohm;
441          df->comp[0].cspec[0] = c_dfcolor; /* XXX monochrome for now */
442          df->comp[0].dist = dp;
443          df->comp[0].func = &SDhandleMtx;
# Line 501 | Line 449 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
449                  return RC_FORMERR;
450          }
451          for (i = 0; i < dp->ninc*dp->nout; i++) {
452 <                char  *sdnext = f_skip(sdata);
452 >                char  *sdnext = fskip(sdata);
453                  if (sdnext == NULL) {
454                          sprintf(SDerrorDetail,
455                                  "Bad/missing BSDF ScatteringData in '%s'",
# Line 558 | Line 506 | extract_diffuse(SDValue *dv, SDSpectralDF *df)
506                  c_cmix(&dv->spec, dv->cieY, &dv->spec, ymin, &df->comp[n].cspec[0]);
507                  dv->cieY += ymin;
508          }
509 <        df->maxHemi -= dv->cieY;        /* correct minimum hemispherical */
510 <        dv->spec.clock++;               /* make sure everything is set */
509 >        df->maxHemi -= dv->cieY;        /* adjust minimum hemispherical */
510 >                                        /* make sure everything is set */
511          c_ccvt(&dv->spec, C_CSXY+C_CSSPEC);
512   }
513  
514   /* Load a BSDF matrix from an open XML file */
515   SDError
516 < SDloadMtx(SDData *sd, ezxml_t fl)
516 > SDloadMtx(SDData *sd, ezxml_t wtl)
517   {
518 <        ezxml_t                 wtl, wld, wdb;
518 >        ezxml_t                 wld, wdb;
519          int                     rowIn;
520          struct BSDF_data        *dp;
521          char                    *txt;
522          int                     rval;
523          
524 <        if (strcmp(ezxml_name(fl), "WindowElement")) {
524 >        txt = ezxml_txt(ezxml_child(ezxml_child(wtl,
525 >                        "DataDefinition"), "IncidentDataStructure"));
526 >        if (txt == NULL || !*txt) {
527                  sprintf(SDerrorDetail,
528 <                        "BSDF \"%s\": top level node not 'WindowElement'",
528 >                        "BSDF \"%s\": missing IncidentDataStructure",
529                                  sd->name);
530                  return SDEformat;
531          }
582 –        wtl = ezxml_child(ezxml_child(fl, "Optical"), "Layer");
583 –        txt = ezxml_txt(ezxml_child(ezxml_child(wtl,
584 –                        "DataDefinition"), "IncidentDataStructure"));
532          if (!strcasecmp(txt, "Rows"))
533                  rowIn = 1;
534          else if (!strcasecmp(txt, "Columns"))
# Line 596 | Line 543 | SDloadMtx(SDData *sd, ezxml_t fl)
543          rval = load_angle_basis(ezxml_child(ezxml_child(wtl,
544                                  "DataDefinition"), "AngleBasis"));
545          if (rval < 0)
546 <                goto err_return;
546 >                return convert_errcode(rval);
547                                  /* load BSDF components */
548          for (wld = ezxml_child(wtl, "WavelengthData");
549                                  wld != NULL; wld = wld->next) {
# Line 606 | Line 553 | SDloadMtx(SDData *sd, ezxml_t fl)
553                  for (wdb = ezxml_child(wld, "WavelengthDataBlock");
554                                          wdb != NULL; wdb = wdb->next)
555                          if ((rval = load_bsdf_data(sd, wdb, rowIn)) < 0)
556 <                                goto err_return;
556 >                                return convert_errcode(rval);
557          }
558                                  /* separate diffuse components */
559          extract_diffuse(&sd->rLambFront, sd->rf);
# Line 614 | Line 561 | SDloadMtx(SDData *sd, ezxml_t fl)
561          extract_diffuse(&sd->tLamb, sd->tf);
562                                  /* return success */
563          return SDEnone;
617 – err_return:                     /* jump here on failure */
618 –        if (sd->rf != NULL) {
619 –                SDfreeSpectralDF(sd->rf);
620 –                sd->rf = NULL;
621 –        }
622 –        if (sd->rb != NULL) {
623 –                SDfreeSpectralDF(sd->rb);
624 –                sd->rb = NULL;
625 –        }
626 –        if (sd->tf != NULL) {
627 –                SDfreeSpectralDF(sd->tf);
628 –                sd->tf = NULL;
629 –        }
630 –        return convert_errcode(rval);
564   }
565  
566   /* Get Matrix BSDF value */
# Line 656 | Line 589 | static SDError
589   SDqueryMtxProjSA(double *psa, const FVECT vec, int qflags, const void *dist)
590   {
591          const SDMat     *dp = (const SDMat *)dist;
592 <
593 <        if (!(qflags & SDqueryInc+SDqueryOut))
592 >        double          inc_psa, out_psa;
593 >                                        /* check arguments */
594 >        if ((psa == NULL) | (vec == NULL) | (dp == NULL))
595                  return SDEargument;
596 <        if (qflags & SDqueryInc) {
597 <                double  inc_psa = mBSDF_incohm(dp, mBSDF_incndx(dp, vec));
598 <                if (inc_psa < .0)
599 <                        return SDEinternal;
600 <                switch (qflags & SDqueryMin+SDqueryMax) {
601 <                case SDqueryMax:
602 <                        if (inc_psa > psa[0])
603 <                                psa[0] = inc_psa;
604 <                        break;
605 <                case SDqueryMin+SDqueryMax:
672 <                        if (inc_psa > psa[1])
673 <                                psa[1] = inc_psa;
674 <                        /* fall through */
675 <                case SDqueryMin:
676 <                        if (inc_psa < psa[0])
677 <                                psa[0] = inc_psa;
678 <                        break;
679 <                case 0:
596 >                                        /* get projected solid angles */
597 >        inc_psa = mBSDF_incohm(dp, mBSDF_incndx(dp, vec));
598 >        out_psa = mBSDF_outohm(dp, mBSDF_outndx(dp, vec));
599 >
600 >        switch (qflags) {               /* record based on flag settings */
601 >        case SDqueryVal:
602 >                psa[0] = .0;
603 >                /* fall through */
604 >        case SDqueryMax:
605 >                if (inc_psa > psa[0])
606                          psa[0] = inc_psa;
607 <                        break;
608 <                }
607 >                if (out_psa > psa[0])
608 >                        psa[0] = out_psa;
609 >                break;
610 >        case SDqueryMin+SDqueryMax:
611 >                if (inc_psa > psa[0])
612 >                        psa[1] = inc_psa;
613 >                if (out_psa > psa[0])
614 >                        psa[1] = out_psa;
615 >                /* fall through */
616 >        case SDqueryMin:
617 >                if ((inc_psa > .0) & (inc_psa < psa[0]))
618 >                        psa[0] = inc_psa;
619 >                if ((out_psa > .0) & (out_psa < psa[0]))
620 >                        psa[0] = out_psa;
621 >                break;
622          }
623 <        if (qflags & SDqueryOut) {
624 <                double  out_psa = mBSDF_outohm(dp, mBSDF_outndx(dp, vec));
686 <                if (out_psa < .0)
687 <                        return SDEinternal;
688 <                switch (qflags & SDqueryMin+SDqueryMax) {
689 <                case SDqueryMax:
690 <                        if (out_psa > psa[0])
691 <                                psa[0] = out_psa;
692 <                        break;
693 <                case SDqueryMin+SDqueryMax:
694 <                        if (out_psa > psa[1])
695 <                                psa[1] = out_psa;
696 <                        /* fall through */
697 <                case SDqueryMin:
698 <                        if (out_psa < psa[0])
699 <                                psa[0] = out_psa;
700 <                        break;
701 <                case 0:
702 <                        psa[(qflags&SDqueryInc)!=0] = out_psa;
703 <                        break;
704 <                }
705 <        }
706 <        return SDEnone;
623 >                                        /* make sure it's legal */
624 >        return (psa[0] <= .0) ? SDEinternal : SDEnone;
625   }
626  
627   /* Compute new cumulative distribution from BSDF */
# Line 745 | Line 663 | SDgetMtxCDist(const FVECT inVec, SDComponent *sdc)
663          int             reverse;
664          SDMatCDst       myCD;
665          SDMatCDst       *cd, *cdlast;
666 <
667 <        if (dp == NULL)
666 >                                        /* check arguments */
667 >        if ((inVec == NULL) | (dp == NULL))
668                  return NULL;
669          memset(&myCD, 0, sizeof(myCD));
670          myCD.indx = mBSDF_incndx(dp, inVec);
# Line 801 | Line 719 | SDsampMtxCDist(FVECT outVec, double randX, const SDCDs
719          const SDMatCDst *mcd = (const SDMatCDst *)cdp;
720          const unsigned  target = randX*maxval;
721          int             i, iupper, ilower;
722 +                                        /* check arguments */
723 +        if ((outVec == NULL) | (mcd == NULL))
724 +                return SDEargument;
725                                          /* binary search to find index */
726          ilower = 0; iupper = mcd->calen;
727          while ((i = (iupper + ilower) >> 1) != ilower)

Diff Legend

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