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

Comparing ray/src/common/bsdf_t.c (file contents):
Revision 3.37 by greg, Sun Apr 5 01:32:01 2015 UTC vs.
Revision 3.49 by greg, Sat Mar 27 15:53:01 2021 UTC

# Line 569 | Line 569 | SDqueryTre(const SDTre *sdt, float *coef,
569                  return 0;               /* should be internal error */
570                                          /* get BSDF value */
571          yval = SDlookupTre(sdt->stc[tt_Y], gridPos, hc);
572 +        if (coef == NULL)               /* just getting hypercube? */
573 +                return 1;
574          if (sdt->stc[tt_u] == NULL || sdt->stc[tt_v] == NULL) {
575 <                if (coef != NULL) *coef = yval;
575 >                *coef = yval;
576                  return 1;               /* no color */
577          }
576 –        if (coef == NULL)               /* just getting hypercube? */
577 –                return 1;
578                                          /* else decode color */
579          SDyuv2rgb(yval, SDlookupTre(sdt->stc[tt_u], gridPos, NULL),
580                          SDlookupTre(sdt->stc[tt_v], gridPos, NULL), coef);
# Line 744 | Line 744 | make_cdist(const SDTre *sdt, const double *invec, int
744   const SDCDst *
745   SDgetTreCDist(const FVECT inVec, SDComponent *sdc)
746   {
747 +        unsigned long   cacheLeft = SDmaxCache;
748          const SDTre     *sdt;
749          double          inCoord[2];
750          int             i;
751          int             mode;
752 <        SDTreCDst       *cd, *cdlast;
752 >        SDTreCDst       *cd, *cdlast, *cdlimit;
753                                          /* check arguments */
754          if ((inVec == NULL) | (sdc == NULL) ||
755                          (sdt = (SDTre *)sdc->dist) == NULL)
# Line 788 | Line 789 | SDgetTreCDist(const FVECT inVec, SDComponent *sdc)
789                                          /* quantize to avoid f.p. errors */
790          for (i = sdt->stc[tt_Y]->ndim - 2; i--; )
791                  inCoord[i] = floor(inCoord[i]/quantum)*quantum + .5*quantum;
792 <        cdlast = NULL;                  /* check for direction in cache list */
792 >        cdlast = cdlimit = NULL;        /* check for direction in cache list */
793 >        /* PLACE MUTEX LOCK HERE FOR THREAD-SAFE */
794          for (cd = (SDTreCDst *)sdc->cdList; cd != NULL;
795                                          cdlast = cd, cd = cd->next) {
796 +                if (cacheLeft) {        /* check cache size limit */
797 +                        long    csiz = sizeof(SDTreCDst) +
798 +                                        sizeof(cd->carr[0])*cd->calen;
799 +                        if (cacheLeft > csiz)
800 +                                cacheLeft -= csiz;
801 +                        else {
802 +                                cdlimit = cdlast;
803 +                                cacheLeft = 0;
804 +                        }
805 +                }
806                  if (cd->sidef != mode)
807                          continue;
808                  for (i = sdt->stc[tt_Y]->ndim - 2; i--; )
# Line 800 | Line 812 | SDgetTreCDist(const FVECT inVec, SDComponent *sdc)
812                  if (i < 0)
813                          break;          /* means we have a match */
814          }
815 <        if (cd == NULL)                 /* need to create new entry? */
815 >        if (cd == NULL) {               /* need to create new entry? */
816 >                if (cdlimit != NULL)    /* exceeded cache size limit? */
817 >                        while ((cd = cdlimit->next) != NULL) {
818 >                                cdlimit->next = cd->next;
819 >                                free(cd);
820 >                        }
821                  cdlast = cd = make_cdist(sdt, inCoord, mode != sdt->sidef);
822 +        }
823          if (cdlast != NULL) {           /* move entry to head of cache list */
824                  cdlast->next = cd->next;
825                  cd->next = (SDTreCDst *)sdc->cdList;
826                  sdc->cdList = (SDCDst *)cd;
827          }
828 +        /* END MUTEX LOCK */
829          return (SDCDst *)cd;            /* ready to go */
830   }
831  
# Line 924 | Line 943 | next_token(char **spp)
943   }
944  
945   /* Advance pointer past matching token (or any token if c==0) */
946 < #define eat_token(spp,c)        (next_token(spp)==(c) ^ !(c) ? *(*(spp))++ : 0)
946 > #define eat_token(spp,c)        ((next_token(spp)==(c)) ^ !(c) ? *(*(spp))++ : 0)
947  
948   /* Count words from this point in string to '}' */
949   static int
# Line 1174 | Line 1193 | SDsubtractTreVal(SDNode *st, float val)
1193   static double
1194   subtract_min_Y(SDNode *st)
1195   {
1196 <        float   vmin;
1196 >        const float     vmaxmin = 1.5/M_PI;
1197 >        float           vmin;
1198                                          /* be sure to skip unused portion */
1199          if (st->ndim == 3) {
1200                  int     n;
1201 <                vmin = 1./M_PI;
1201 >                vmin = vmaxmin;
1202                  if (st->log2GR < 0) {
1203                          for (n = 0; n < 8; n += 2) {
1204                                  float   v = SDgetTreMin(st->u.t[n]);
# Line 1194 | Line 1214 | subtract_min_Y(SDNode *st)
1214          } else                          /* anisotropic covers entire tree */
1215                  vmin = SDgetTreMin(st);
1216  
1217 <        if (vmin <= FTINY)
1218 <                return .0;
1217 >        if ((vmin >= vmaxmin) | (vmin <= .01/M_PI))
1218 >                return .0;              /* not worth bothering about */
1219  
1220          SDsubtractTreVal(st, vmin);
1221  
# Line 1241 | Line 1261 | adjust_utree(float uprime, const double *cmin, double
1261   {
1262          SDextRGBs       *mp = (SDextRGBs *)cptr;
1263          double          cmax[SD_MAXDIM];
1264 +        double          yval;
1265          float           rgb[3];
1266 <        int             ok;
1266 >        C_COLOR         clr;
1267  
1268          if (mp->stc[tt_Y]->ndim == 3) {
1269                  if (cmin[0] + .5*csiz >= .5)
# Line 1253 | Line 1274 | adjust_utree(float uprime, const double *cmin, double
1274          cmax[1] = cmin[1] + csiz;
1275          cmax[2] = cmin[2] + csiz;
1276                                          /* average RGB color over voxel */
1277 <        SDyuv2rgb(SDavgTreBox(mp->stc[tt_Y], cmin, cmax), uprime,
1277 >        SDyuv2rgb(yval=SDavgTreBox(mp->stc[tt_Y], cmin, cmax), uprime,
1278                          SDavgTreBox(mp->stc[tt_v], cmin, cmax), rgb);
1279 <                                        /* subtract minimum */
1280 <        ok = (rgb[0] -= mp->rgb[0]) > 1e-5;
1281 <        ok &= (rgb[1] -= mp->rgb[1]) > 1e-5;
1282 <        ok &= (rgb[2] -= mp->rgb[2]) > 1e-5;
1283 <        if (ok) {                       /* compute new u' for adj. RGB */
1284 <                C_COLOR clr;
1264 <                c_fromSharpRGB(rgb, &clr);
1265 <                uprime = 4.*clr.cx/(-2.*clr.cx + 12.*clr.cy + 3.);
1266 <        } else
1267 <                uprime = 4./3./(-2./3. + 12./3. + 3.);
1279 >                                        /* subtract minimum (& clamp) */
1280 >        if ((rgb[0] -= mp->rgb[0]) < 1e-5*yval) rgb[0] = 1e-5*yval;
1281 >        if ((rgb[1] -= mp->rgb[1]) < 1e-5*yval) rgb[1] = 1e-5*yval;
1282 >        if ((rgb[2] -= mp->rgb[2]) < 1e-5*yval) rgb[2] = 1e-5*yval;
1283 >        c_fromSharpRGB(rgb, &clr);      /* compute new u' for adj. RGB */
1284 >        uprime = 4.*clr.cx/(-2.*clr.cx + 12.*clr.cy + 3.);
1285                                          /* assign in new u' tree */
1286          mp->new_stu = SDsetVoxel(mp->new_stu, mp->stc[tt_Y]->ndim,
1287                                          cmin, csiz, uprime);
# Line 1277 | Line 1294 | adjust_vtree(float vprime, const double *cmin, double
1294   {
1295          SDextRGBs       *mp = (SDextRGBs *)cptr;
1296          double          cmax[SD_MAXDIM];
1297 +        double          yval;
1298          float           rgb[3];
1299 <        int             ok;
1299 >        C_COLOR         clr;
1300  
1301          if (mp->stc[tt_Y]->ndim == 3) {
1302                  if (cmin[0] + .5*csiz >= .5)
# Line 1289 | Line 1307 | adjust_vtree(float vprime, const double *cmin, double
1307          cmax[1] = cmin[1] + csiz;
1308          cmax[2] = cmin[2] + csiz;
1309                                          /* average RGB color over voxel */
1310 <        SDyuv2rgb(SDavgTreBox(mp->stc[tt_Y], cmin, cmax),
1310 >        SDyuv2rgb(yval=SDavgTreBox(mp->stc[tt_Y], cmin, cmax),
1311                          SDavgTreBox(mp->stc[tt_u], cmin, cmax),
1312                          vprime, rgb);
1313 <                                        /* subtract minimum */
1314 <        ok = (rgb[0] -= mp->rgb[0]) > 1e-5;
1315 <        ok &= (rgb[1] -= mp->rgb[1]) > 1e-5;
1316 <        ok &= (rgb[2] -= mp->rgb[2]) > 1e-5;
1317 <        if (ok) {                       /* compute new v' for adj. RGB */
1318 <                C_COLOR clr;
1301 <                c_fromSharpRGB(rgb, &clr);
1302 <                vprime = 9.*clr.cy/(-2.*clr.cx + 12.*clr.cy + 3.);
1303 <        } else
1304 <                vprime = 9./3./(-2./3. + 12./3. + 3.);
1313 >                                        /* subtract minimum (& clamp) */
1314 >        if ((rgb[0] -= mp->rgb[0]) < 1e-5*yval) rgb[0] = 1e-5*yval;
1315 >        if ((rgb[1] -= mp->rgb[1]) < 1e-5*yval) rgb[1] = 1e-5*yval;
1316 >        if ((rgb[2] -= mp->rgb[2]) < 1e-5*yval) rgb[2] = 1e-5*yval;
1317 >        c_fromSharpRGB(rgb, &clr);      /* compute new v' for adj. RGB */
1318 >        vprime = 9.*clr.cy/(-2.*clr.cx + 12.*clr.cy + 3.);
1319                                          /* assign in new v' tree */
1320          mp->new_stv = SDsetVoxel(mp->new_stv, mp->stc[tt_Y]->ndim,
1321                                          cmin, csiz, vprime);
# Line 1320 | Line 1334 | subtract_min_RGB(C_COLOR *cs, SDNode *stc[])
1334          my_min.new_stu = my_min.new_stv = NULL;
1335                                          /* get minimum RGB value */
1336          SDtraverseTre(stc[tt_Y], NULL, 0, get_min_RGB, &my_min);
1337 <        ymin = tt_RGB_coef[0]*my_min.rgb[0] +
1338 <                        tt_RGB_coef[1]*my_min.rgb[1] +
1339 <                                        tt_RGB_coef[2]*my_min.rgb[2];
1340 <        if (ymin <= 1e-5) {
1341 <                *cs = c_dfcolor;
1328 <                return .0;              /* not worth bothering about */
1329 <        }
1330 <                                        /* adjust u' & v' values */
1337 >                                        /* convert to C_COLOR */
1338 >        ymin =  c_fromSharpRGB(my_min.rgb, cs);
1339 >        if ((ymin >= .5*FHUGE) | (ymin <= .01/M_PI))
1340 >                return .0;              /* close to zero or no tree */
1341 >                                        /* adjust u' & v' trees */
1342          SDtraverseTre(stc[tt_u], NULL, 0, adjust_utree, &my_min);
1343          SDtraverseTre(stc[tt_v], NULL, 0, adjust_vtree, &my_min);
1344          SDfreeTre(stc[tt_u]); SDfreeTre(stc[tt_v]);
1345          stc[tt_u] = SDsimplifyTre(my_min.new_stu);
1346          stc[tt_v] = SDsimplifyTre(my_min.new_stv);
1347 <                                        /* finally, subtract Y value */
1347 >                                        /* subtract Y & return hemispherical */
1348          SDsubtractTreVal(stc[tt_Y], ymin);
1349 <                                        /* return color and Y */
1350 <        c_fromSharpRGB(my_min.rgb, cs);
1340 <        return M_PI*ymin;
1349 >
1350 >        return M_PI * ymin;
1351   }
1352  
1353   /* Extract and separate diffuse portion of BSDF */
# Line 1364 | Line 1374 | extract_diffuse(SDValue *dv, SDSpectralDF *df)
1374                  memcpy(df->comp[0].cspec, tt_RGB_prim, sizeof(tt_RGB_prim));
1375                  dv->cieY = subtract_min_RGB(&dv->spec, sdt->stc);
1376          } else {
1377 <                df->comp[0].cspec[0] = c_dfcolor;
1377 >                df->comp[0].cspec[0] = dv->spec = c_dfcolor;
1378                  dv->cieY = subtract_min_Y(sdt->stc[tt_Y]);
1379          }
1380          df->maxHemi -= dv->cieY;        /* adjust maximum hemispherical */
1381 <                                        /* make sure everything is set */
1382 <        c_ccvt(&dv->spec, C_CSXY+C_CSSPEC);
1381 >                                
1382 >        c_ccvt(&dv->spec, C_CSXY);      /* make sure (x,y) is set */
1383   }
1384  
1385   /* Load a variable-resolution BSDF tree from an open XML file */
# Line 1420 | Line 1430 | SDloadTre(SDData *sd, ezxml_t wtl)
1430                                          /* separate diffuse components */
1431          extract_diffuse(&sd->rLambFront, sd->rf);
1432          extract_diffuse(&sd->rLambBack, sd->rb);
1423 –        if (sd->tf != NULL)
1424 –                extract_diffuse(&sd->tLamb, sd->tf);
1433          if (sd->tb != NULL)
1434                  extract_diffuse(&sd->tLamb, sd->tb);
1435 +        if (sd->tf != NULL)
1436 +                extract_diffuse(&sd->tLamb, sd->tf);
1437                                          /* return success */
1438          return SDEnone;
1439   }
1440  
1441   /* Variable resolution BSDF methods */
1442 < SDFunc SDhandleTre = {
1442 > const SDFunc SDhandleTre = {
1443          &SDgetTreBSDF,
1444          &SDqueryTreProjSA,
1445          &SDgetTreCDist,

Diff Legend

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