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

Comparing ray/src/util/cmbsdf.c (file contents):
Revision 2.4 by greg, Thu Aug 27 04:33:31 2015 UTC vs.
Revision 2.9 by greg, Tue Jan 19 23:32:00 2021 UTC

# Line 28 | Line 28 | cm_bsdf(const COLOR diffBSDF, const SDMat *bsdf)
28                  nbadohm += (dom <= 0);
29  
30                  for (r = 0; r < cm->nrows; r++) {
31 <                        float   f = mBSDF_value(bsdf,c,r);
31 >                        float   f = mBSDF_value(bsdf,r,c);
32                          COLORV  *mp = cm_lval(cm,r,c);
33                                          /* check BSDF value */
34                          if ((f <= 0) | (dom <= 0)) {
# Line 36 | Line 36 | cm_bsdf(const COLOR diffBSDF, const SDMat *bsdf)
36                                  setcolor(mp, .0f, .0f, .0f);
37                          } else if (bsdf->chroma != NULL) {
38                                  C_COLOR cxy;
39 <                                c_decodeChroma(&cxy, mBSDF_chroma(bsdf,c,r));
39 >                                c_decodeChroma(&cxy, mBSDF_chroma(bsdf,r,c));
40                                  ccy2rgb(&cxy, f, mp);
41                          } else
42                                  setcolor(mp, f, f, f);
# Line 94 | Line 94 | cm_bsdf_recip(const COLOR diffBSDF, const SDMat *bsdf)
94  
95                  for (r = 0; r < cm->nrows; r++) {
96                          const int       ri = recip_in_from_out(bsdf,r);
97 <                        float           f = mBSDF_value(bsdf,ri,ro);
97 >                        float           f = mBSDF_value(bsdf,ro,ri);
98                          COLORV          *mp = cm_lval(cm,r,c);
99                                          /* check BSDF value */
100                          if ((f <= 0) | (dom <= 0)) {
# Line 102 | Line 102 | cm_bsdf_recip(const COLOR diffBSDF, const SDMat *bsdf)
102                                  setcolor(mp, .0f, .0f, .0f);
103                          } else if (bsdf->chroma != NULL) {
104                                  C_COLOR cxy;
105 <                                c_decodeChroma(&cxy, mBSDF_chroma(bsdf,ri,ro));
105 >                                c_decodeChroma(&cxy, mBSDF_chroma(bsdf,ro,ri));
106                                  ccy2rgb(&cxy, f, mp);
107                          } else
108                                  setcolor(mp, f, f, f);
# Line 123 | Line 123 | cm_bsdf_recip(const COLOR diffBSDF, const SDMat *bsdf)
123   static CMATRIX *
124   cm_bsdf_Lamb(const COLOR diffBSDF)
125   {
126 <        CMATRIX *cm = cm_alloc(145, 145);       /* this is a hack */
127 <        int     r, c;
126 >        CMATRIX         *cm = cm_alloc(145, 145);       /* this is a hack */
127 >        ANGLE_BASIS     *abase = abase_list;
128 >        int             r, c;
129  
130 <        for (c = 0; c < cm->ncols; c++)
130 >        while (abase->nangles != cm->nrows)
131 >                if (++abase >= abase_list+nabases)
132 >                        error(INTERNAL, "Code error in cm_bsdf_Lamb()");
133 >
134 >        for (c = 0; c < cm->ncols; c++) {
135 >                const double    dom = io_getohm(c,abase);
136                  for (r = 0; r < cm->nrows; r++) {
137                          COLORV  *mp = cm_lval(cm,r,c);
138                          copycolor(mp, diffBSDF);
139 +                        scalecolor(mp, dom);
140                  }
141 +        }
142          return(cm);
143   }
144  
145   /* Load and convert a matrix BTDF from the given XML file */
146   CMATRIX *
147 < cm_loadBTDF(char *fname)
147 > cm_loadBTDF(const char *fname)
148   {
149          CMATRIX         *Tmat;
142 –        char            *fpath;
150          int             recip;
151          SDError         ec;
152          SDData          myBSDF;
153          SDSpectralDF    *tdf;
154 <        COLOR           diffBSDF;
155 <                                        /* find path to BSDF file */
149 <        fpath = getpath(fname, getrlibpath(), R_OK);
150 <        if (fpath == NULL) {
151 <                sprintf(errmsg, "cannot find BSDF file '%s'", fname);
152 <                error(USER, errmsg);
153 <        }
154 >        COLOR           diffBTDF;
155 >
156          SDclearBSDF(&myBSDF, fname);    /* load XML and check type */
157 <        ec = SDloadFile(&myBSDF, fpath);
157 >        ec = SDloadFile(&myBSDF, fname);
158          if (ec)
159                  error(USER, transSDError(ec));
160 <        ccy2rgb(&myBSDF.tLamb.spec, myBSDF.tLamb.cieY/PI, diffBSDF);
160 >        ccy2rgb(&myBSDF.tLamb.spec, myBSDF.tLamb.cieY/PI, diffBTDF);
161          recip = (myBSDF.tb == NULL);
162          tdf = recip ? myBSDF.tf : myBSDF.tb;
163          if (tdf == NULL) {              /* no non-Lambertian transmission? */
164                  SDfreeBSDF(&myBSDF);
165 <                return(cm_bsdf_Lamb(diffBSDF));
165 >                return(cm_bsdf_Lamb(diffBTDF));
166          }
167          if (tdf->ncomp != 1 || tdf->comp[0].func != &SDhandleMtx) {
168 <                sprintf(errmsg, "unsupported BSDF '%s'", fpath);
168 >                sprintf(errmsg, "unsupported BSDF '%s'", fname);
169                  error(USER, errmsg);
170          }
171                                          /* convert BTDF to matrix */
172 <        Tmat = recip ? cm_bsdf_recip(diffBSDF, (SDMat *)tdf->comp[0].dist)
173 <                        : cm_bsdf(diffBSDF, (SDMat *)tdf->comp[0].dist);
172 >        Tmat = recip ? cm_bsdf_recip(diffBTDF, (SDMat *)tdf->comp[0].dist)
173 >                        : cm_bsdf(diffBTDF, (SDMat *)tdf->comp[0].dist);
174                                          /* free BSDF and return */
175          SDfreeBSDF(&myBSDF);
176          return(Tmat);
177 + }
178 +
179 + /* Load and convert a matrix BRDF from the given XML file */
180 + CMATRIX *
181 + cm_loadBRDF(const char *fname, int backside)
182 + {
183 +        CMATRIX         *Rmat;
184 +        SDError         ec;
185 +        SDData          myBSDF;
186 +        SDSpectralDF    *rdf;
187 +        COLOR           diffBRDF;
188 +
189 +        SDclearBSDF(&myBSDF, fname);    /* load XML and check type */
190 +        ec = SDloadFile(&myBSDF, fname);
191 +        if (ec)
192 +                error(USER, transSDError(ec));
193 +        if (backside) {
194 +                ccy2rgb(&myBSDF.rLambBack.spec, myBSDF.rLambBack.cieY/PI, diffBRDF);
195 +                rdf = myBSDF.rb;
196 +        } else {
197 +                ccy2rgb(&myBSDF.rLambFront.spec, myBSDF.rLambFront.cieY/PI, diffBRDF);
198 +                rdf = myBSDF.rf;
199 +        }
200 +        if (rdf == NULL) {              /* no non-Lambertian reflection? */
201 +                SDfreeBSDF(&myBSDF);
202 +                return(cm_bsdf_Lamb(diffBRDF));
203 +        }
204 +        if (rdf->ncomp != 1 || rdf->comp[0].func != &SDhandleMtx) {
205 +                sprintf(errmsg, "unsupported BSDF '%s'", fname);
206 +                error(USER, errmsg);
207 +        }
208 +                                        /* convert BRDF to matrix */
209 +        Rmat = cm_bsdf(diffBRDF, (SDMat *)rdf->comp[0].dist);
210 +                                        /* free BSDF and return */
211 +        SDfreeBSDF(&myBSDF);
212 +        return(Rmat);
213   }

Diff Legend

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