src/util/cmbsdf.c

#ifndef lint
static const char RCSid[] = "$Id: cmbsdf.c,v 2.8 2020/03/17 23:24:05 greg Exp $";
#endif
/*
 * Load and convert BSDF into color coefficient matrix representation.
 *
 *      G. Ward
 */

#include "standard.h"
#include "cmatrix.h"
#include "paths.h"
#include "bsdf.h"
#include "bsdf_m.h"

/* Convert a BSDF to our matrix representation */
static CMATRIX *
cm_bsdf(const COLOR diffBSDF, const SDMat *bsdf)
{
        CMATRIX *cm = cm_alloc(bsdf->nout, bsdf->ninc);
        int     nbadohm = 0;
        int     nneg = 0;
        int     r, c;
                                        /* loop over incident angles */
        for (c = 0; c < cm->ncols; c++) {
                const double    dom = mBSDF_incohm(bsdf,c);
                                        /* projected solid angle */
                nbadohm += (dom <= 0);

                for (r = 0; r < cm->nrows; r++) {
                        float   f = mBSDF_value(bsdf,r,c);
                        COLORV  *mp = cm_lval(cm,r,c);
                                        /* check BSDF value */
                        if ((f <= 0) | (dom <= 0)) {
                                nneg += (f < -FTINY);
                                setcolor(mp, .0f, .0f, .0f);
                        } else if (bsdf->chroma != NULL) {
                                C_COLOR cxy;
                                c_decodeChroma(&cxy, mBSDF_chroma(bsdf,r,c));
                                ccy2rgb(&cxy, f, mp);
                        } else
                                setcolor(mp, f, f, f);
                        addcolor(mp, diffBSDF);
                        scalecolor(mp, dom);
                }
        }
        if (nneg | nbadohm) {
                sprintf(errmsg,
                    "BTDF has %d negatives and %d bad incoming solid angles",
                                nneg, nbadohm);
                error(WARNING, errmsg);
        }
        return(cm);
}

/* Convert between input and output indices for reciprocity */
static int
recip_out_from_in(const SDMat *bsdf, int in_recip)
{
        FVECT   v;

        if (!mBSDF_incvec(v, bsdf, in_recip+.5))
                return(in_recip);               /* XXX should be error! */
        v[2] = -v[2];
        return(mBSDF_outndx(bsdf, v));
}

/* Convert between output and input indices for reciprocity */
static int
recip_in_from_out(const SDMat *bsdf, int out_recip)
{
        FVECT   v;

        if (!mBSDF_outvec(v, bsdf, out_recip+.5))
                return(out_recip);              /* XXX should be error! */
        v[2] = -v[2];
        return(mBSDF_incndx(bsdf, v));
}

/* Convert a BSDF to our matrix representation, applying reciprocity */
static CMATRIX *
cm_bsdf_recip(const COLOR diffBSDF, const SDMat *bsdf)
{
        CMATRIX *cm = cm_alloc(bsdf->ninc, bsdf->nout);
        int     nbadohm = 0;
        int     nneg = 0;
        int     r, c;
                                        /* loop over incident angles */
        for (c = 0; c < cm->ncols; c++) {
                const int       ro = recip_out_from_in(bsdf,c);
                const double    dom = mBSDF_outohm(bsdf,ro);
                                        /* projected solid angle */
                nbadohm += (dom <= 0);

                for (r = 0; r < cm->nrows; r++) {
                        const int       ri = recip_in_from_out(bsdf,r);
                        float           f = mBSDF_value(bsdf,ro,ri);
                        COLORV          *mp = cm_lval(cm,r,c);
                                        /* check BSDF value */
                        if ((f <= 0) | (dom <= 0)) {
                                nneg += (f < -FTINY);
                                setcolor(mp, .0f, .0f, .0f);
                        } else if (bsdf->chroma != NULL) {
                                C_COLOR cxy;
                                c_decodeChroma(&cxy, mBSDF_chroma(bsdf,ro,ri));
                                ccy2rgb(&cxy, f, mp);
                        } else
                                setcolor(mp, f, f, f);
                        addcolor(mp, diffBSDF);
                        scalecolor(mp, dom);
                }
        }
        if (nneg | nbadohm) {
                sprintf(errmsg,
                    "BTDF has %d negatives and %d bad incoming solid angles",
                                nneg, nbadohm);
                error(WARNING, errmsg);
        }
        return(cm);
}

/* Return a Lambertian (diffuse) matrix */
static CMATRIX *
cm_bsdf_Lamb(const COLOR diffBSDF)
{
        CMATRIX         *cm = cm_alloc(145, 145);       /* this is a hack */
        ANGLE_BASIS     *abase = abase_list;
        int             r, c;

        while (abase->nangles != cm->nrows)
                if (++abase >= abase_list+nabases)
                        error(INTERNAL, "Code error in cm_bsdf_Lamb()");

        for (c = 0; c < cm->ncols; c++) {
                const double    dom = io_getohm(c,abase);
                for (r = 0; r < cm->nrows; r++) {
                        COLORV  *mp = cm_lval(cm,r,c);
                        copycolor(mp, diffBSDF);
                        scalecolor(mp, dom);
                }
        }
        return(cm);
}

/* Load and convert a matrix BTDF from the given XML file */
CMATRIX *
cm_loadBTDF(const char *fname)
{
        CMATRIX         *Tmat;
        int             recip;
        SDError         ec;
        SDData          myBSDF;
        SDSpectralDF    *tdf;
        COLOR           diffBTDF;

        SDclearBSDF(&myBSDF, fname);    /* load XML and check type */
        ec = SDloadFile(&myBSDF, fname);
        if (ec)
                error(USER, transSDError(ec));
        ccy2rgb(&myBSDF.tLamb.spec, myBSDF.tLamb.cieY/PI, diffBTDF);
        recip = (myBSDF.tb == NULL);
        tdf = recip ? myBSDF.tf : myBSDF.tb;
        if (tdf == NULL) {              /* no non-Lambertian transmission? */
                SDfreeBSDF(&myBSDF);
                return(cm_bsdf_Lamb(diffBTDF));
        }
        if (tdf->ncomp != 1 || tdf->comp[0].func != &SDhandleMtx) {
                sprintf(errmsg, "unsupported BSDF '%s'", fname);
                error(USER, errmsg);
        }
                                        /* convert BTDF to matrix */
        Tmat = recip ? cm_bsdf_recip(diffBTDF, (SDMat *)tdf->comp[0].dist)
                        : cm_bsdf(diffBTDF, (SDMat *)tdf->comp[0].dist);
                                        /* free BSDF and return */
        SDfreeBSDF(&myBSDF);
        return(Tmat);
}

/* Load and convert a matrix BRDF from the given XML file */
CMATRIX *
cm_loadBRDF(const char *fname, int backside)
{
        CMATRIX         *Rmat;
        SDError         ec;
        SDData          myBSDF;
        SDSpectralDF    *rdf;
        COLOR           diffBRDF;

        SDclearBSDF(&myBSDF, fname);    /* load XML and check type */
        ec = SDloadFile(&myBSDF, fname);
        if (ec)
                error(USER, transSDError(ec));
        if (backside) {
                ccy2rgb(&myBSDF.rLambBack.spec, myBSDF.rLambBack.cieY/PI, diffBRDF);
                rdf = myBSDF.rb;
        } else {
                ccy2rgb(&myBSDF.rLambFront.spec, myBSDF.rLambFront.cieY/PI, diffBRDF);
                rdf = myBSDF.rf;
        }
        if (rdf == NULL) {              /* no non-Lambertian reflection? */
                SDfreeBSDF(&myBSDF);
                return(cm_bsdf_Lamb(diffBRDF));
        }
        if (rdf->ncomp != 1 || rdf->comp[0].func != &SDhandleMtx) {
                sprintf(errmsg, "unsupported BSDF '%s'", fname);
                error(USER, errmsg);
        }
                                        /* convert BRDF to matrix */
        Rmat = cm_bsdf(diffBRDF, (SDMat *)rdf->comp[0].dist);
                                        /* free BSDF and return */
        SDfreeBSDF(&myBSDF);
        return(Rmat);
}
Revision:	2.9
Committed:	Tue Jan 19 23:32:00 2021 UTC (4 years, 9 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.8:	+43 -7 lines
Log Message:	feat: Added -rf and -rb options to rmtxop to load XML reflectance matrices
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.9	static const char RCSid[] = "$Id: cmbsdf.c,v 2.8 2020/03/17 23:24:05 greg Exp $";
3	greg	2.1	#endif
4			/*
5			* Load and convert BSDF into color coefficient matrix representation.
6			*
7			* G. Ward
8			*/
9
10			#include "standard.h"
11			#include "cmatrix.h"
12			#include "paths.h"
13			#include "bsdf.h"
14			#include "bsdf_m.h"
15
16			/* Convert a BSDF to our matrix representation */
17			static CMATRIX *
18	greg	2.3	cm_bsdf(const COLOR diffBSDF, const SDMat *bsdf)
19	greg	2.1	{
20			CMATRIX *cm = cm_alloc(bsdf->nout, bsdf->ninc);
21			int nbadohm = 0;
22			int nneg = 0;
23			int r, c;
24			/* loop over incident angles */
25			for (c = 0; c < cm->ncols; c++) {
26			const double dom = mBSDF_incohm(bsdf,c);
27			/* projected solid angle */
28			nbadohm += (dom <= 0);
29
30			for (r = 0; r < cm->nrows; r++) {
31	greg	2.7	float f = mBSDF_value(bsdf,r,c);
32	greg	2.1	COLORV *mp = cm_lval(cm,r,c);
33			/* check BSDF value */
34			if ((f <= 0) \| (dom <= 0)) {
35			nneg += (f < -FTINY);
36	greg	2.3	setcolor(mp, .0f, .0f, .0f);
37			} else if (bsdf->chroma != NULL) {
38			C_COLOR cxy;
39	greg	2.7	c_decodeChroma(&cxy, mBSDF_chroma(bsdf,r,c));
40	greg	2.3	ccy2rgb(&cxy, f, mp);
41			} else
42			setcolor(mp, f, f, f);
43	greg	2.2	addcolor(mp, diffBSDF);
44	greg	2.1	scalecolor(mp, dom);
45			}
46			}
47			if (nneg \| nbadohm) {
48			sprintf(errmsg,
49			"BTDF has %d negatives and %d bad incoming solid angles",
50			nneg, nbadohm);
51			error(WARNING, errmsg);
52			}
53			return(cm);
54			}
55
56			/* Convert between input and output indices for reciprocity */
57			static int
58			recip_out_from_in(const SDMat *bsdf, int in_recip)
59			{
60			FVECT v;
61
62			if (!mBSDF_incvec(v, bsdf, in_recip+.5))
63			return(in_recip); /* XXX should be error! */
64			v[2] = -v[2];
65			return(mBSDF_outndx(bsdf, v));
66			}
67
68			/* Convert between output and input indices for reciprocity */
69			static int
70			recip_in_from_out(const SDMat *bsdf, int out_recip)
71			{
72			FVECT v;
73
74			if (!mBSDF_outvec(v, bsdf, out_recip+.5))
75			return(out_recip); /* XXX should be error! */
76			v[2] = -v[2];
77			return(mBSDF_incndx(bsdf, v));
78			}
79
80			/* Convert a BSDF to our matrix representation, applying reciprocity */
81			static CMATRIX *
82	greg	2.3	cm_bsdf_recip(const COLOR diffBSDF, const SDMat *bsdf)
83	greg	2.1	{
84			CMATRIX *cm = cm_alloc(bsdf->ninc, bsdf->nout);
85			int nbadohm = 0;
86			int nneg = 0;
87			int r, c;
88			/* loop over incident angles */
89			for (c = 0; c < cm->ncols; c++) {
90			const int ro = recip_out_from_in(bsdf,c);
91			const double dom = mBSDF_outohm(bsdf,ro);
92			/* projected solid angle */
93			nbadohm += (dom <= 0);
94
95			for (r = 0; r < cm->nrows; r++) {
96			const int ri = recip_in_from_out(bsdf,r);
97	greg	2.7	float f = mBSDF_value(bsdf,ro,ri);
98	greg	2.1	COLORV *mp = cm_lval(cm,r,c);
99			/* check BSDF value */
100			if ((f <= 0) \| (dom <= 0)) {
101			nneg += (f < -FTINY);
102	greg	2.3	setcolor(mp, .0f, .0f, .0f);
103			} else if (bsdf->chroma != NULL) {
104			C_COLOR cxy;
105	greg	2.7	c_decodeChroma(&cxy, mBSDF_chroma(bsdf,ro,ri));
106	greg	2.3	ccy2rgb(&cxy, f, mp);
107			} else
108			setcolor(mp, f, f, f);
109	greg	2.2	addcolor(mp, diffBSDF);
110	greg	2.1	scalecolor(mp, dom);
111			}
112			}
113			if (nneg \| nbadohm) {
114			sprintf(errmsg,
115			"BTDF has %d negatives and %d bad incoming solid angles",
116			nneg, nbadohm);
117			error(WARNING, errmsg);
118			}
119			return(cm);
120			}
121
122	greg	2.2	/* Return a Lambertian (diffuse) matrix */
123			static CMATRIX *
124			cm_bsdf_Lamb(const COLOR diffBSDF)
125			{
126	greg	2.8	CMATRIX cm = cm_alloc(145, 145); / this is a hack */
127			ANGLE_BASIS *abase = abase_list;
128			int r, c;
129
130			while (abase->nangles != cm->nrows)
131			if (++abase >= abase_list+nabases)
132			error(INTERNAL, "Code error in cm_bsdf_Lamb()");
133	greg	2.2
134	greg	2.8	for (c = 0; c < cm->ncols; c++) {
135			const double dom = io_getohm(c,abase);
136	greg	2.2	for (r = 0; r < cm->nrows; r++) {
137			COLORV *mp = cm_lval(cm,r,c);
138			copycolor(mp, diffBSDF);
139	greg	2.8	scalecolor(mp, dom);
140	greg	2.2	}
141	greg	2.8	}
142	greg	2.2	return(cm);
143			}
144
145			/* Load and convert a matrix BTDF from the given XML file */
146	greg	2.1	CMATRIX *
147	greg	2.9	cm_loadBTDF(const char *fname)
148	greg	2.1	{
149			CMATRIX *Tmat;
150			int recip;
151			SDError ec;
152			SDData myBSDF;
153			SDSpectralDF *tdf;
154	greg	2.9	COLOR diffBTDF;
155	greg	2.6
156	greg	2.1	SDclearBSDF(&myBSDF, fname); /* load XML and check type */
157	greg	2.6	ec = SDloadFile(&myBSDF, fname);
158	greg	2.1	if (ec)
159			error(USER, transSDError(ec));
160	greg	2.9	ccy2rgb(&myBSDF.tLamb.spec, myBSDF.tLamb.cieY/PI, diffBTDF);
161	greg	2.1	recip = (myBSDF.tb == NULL);
162			tdf = recip ? myBSDF.tf : myBSDF.tb;
163			if (tdf == NULL) { /* no non-Lambertian transmission? */
164			SDfreeBSDF(&myBSDF);
165	greg	2.9	return(cm_bsdf_Lamb(diffBTDF));
166	greg	2.1	}
167			if (tdf->ncomp != 1 \|\| tdf->comp[0].func != &SDhandleMtx) {
168	greg	2.6	sprintf(errmsg, "unsupported BSDF '%s'", fname);
169	greg	2.1	error(USER, errmsg);
170			}
171			/* convert BTDF to matrix */
172	greg	2.9	Tmat = recip ? cm_bsdf_recip(diffBTDF, (SDMat *)tdf->comp[0].dist)
173			: cm_bsdf(diffBTDF, (SDMat *)tdf->comp[0].dist);
174	greg	2.1	/* free BSDF and return */
175			SDfreeBSDF(&myBSDF);
176			return(Tmat);
177			}
178	greg	2.9
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			}