src/common/testBSDF.c

#ifndef lint
static const char RCSid[] = "$Id: testBSDF.c,v 1.16 2021/03/27 17:50:18 greg Exp $";
#endif
/*
 * Simple test program to demonstrate BSDF operation.
 *
 *      G. Ward         June 2015
 */

#define _USE_MATH_DEFINES
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include "rtio.h"
#include "bsdf.h"

static void
Usage(const char *prog)
{
        printf("Usage: %s [bsdf_directory]\n", prog);
        printf("Input commands:\n");
        printf("  L bsdf.xml\t\t\t Load (make active) given BSDF input file\n");
        printf("  i\t\t\t\t Report general information (metadata)\n");
        printf("  c\t\t\t\t Report diffuse and specular components\n");
        printf("  q theta_i phi_i theta_o phi_o\t Query BSDF for given path (CIE-XYZ)\n");
        printf("  s[r|t][s|d] N theta phi\t Generate N ray directions & colors at given incidence\n");
        printf("  h[s|d] theta phi\t\t Report hemispherical scattering at given incidence\n");
        printf("  r[s|d] theta phi\t\t Report hemispherical reflection at given incidence\n");
        printf("  t[s|d] theta phi\t\t Report hemispherical transmission at given incidence\n");
        printf("  a theta phi [t2 p2]\t\t Report resolution (in proj. steradians) for given direction(s)\n");
        printf("  ^D\t\t\t\t Quit program\n");
}

static void
vec_from_deg(FVECT v, double theta, double phi)
{
        const double    DEG = M_PI/180.;

        theta *= DEG; phi *= DEG;
        v[0] = v[1] = sin(theta);
        v[0] *= cos(phi);
        v[1] *= sin(phi);
        v[2] = cos(theta);
}

static void
printXYZ(const char *intro, const SDValue *vp)
{
        if (vp->cieY <= 1e-9) {
                printf("%s0 0 0\n", intro);
                return;
        }
        printf("%s%.3e %.3e %.3e\n", intro,
                        vp->spec.cx/vp->spec.cy*vp->cieY,
                        vp->cieY,
                        (1.-vp->spec.cx-vp->spec.cy)/
                        vp->spec.cy*vp->cieY);
}

int
main(int argc, char *argv[])
{
        const char      *directory = NULL;
        char            inp[512], path[512];
        const SDData    *bsdf = NULL;

        if (argc > 2 || (argc == 2 && argv[1][0] == '-')) {
                Usage(argv[0]);
                return 1;
        }
        if (argc == 2)
                directory = argv[1];
        
        SDretainSet = SDretainBSDFs;            /* keep BSDFs in memory */

                                                /* loop on command */
        while (fgets(inp, sizeof(inp), stdin)) {
                int     sflags = SDsampAll;
                char    *cp = inp;
                char    *cp2;
                FVECT   vin, vout;
                double  proja[2];
                int     n, i;
                SDValue val;
                
                while (isspace(*cp)) cp++;

                switch (toupper(*cp)) {
                case 'L':                       /* load/activate BSDF input */
                        cp2 = cp = sskip2(cp, 1);
                        if (!*cp)
                                break;
                        while (*cp) cp++;
                        while (isspace(*--cp)) *cp = '\0';
                        if (directory)
                                sprintf(path, "%s/%s", directory, cp2);
                        else
                                strcpy(path, cp2);
                        if (bsdf)
                                SDfreeCache(bsdf);
                        bsdf = SDcacheFile(path);
                        continue;
                case 'I':                       /* report general info. */
                        if (!bsdf)
                                goto noBSDFerr;
                        printf("Material: '%s'\n", bsdf->matn);
                        printf("Manufacturer: '%s'\n", bsdf->makr);
                        printf("Width, Height, Thickness (m): %.4e, %.4e, %.4e\n",
                                        bsdf->dim[0], bsdf->dim[1], bsdf->dim[2]);
                        if (bsdf->mgf)
                                printf("Has geometry: %lu bytes\n",
                                                (unsigned long)strlen(bsdf->mgf));
                        else
                                printf("Has geometry: no\n");
                        break;
                case 'C':                       /* report constant values */
                        if (!bsdf)
                                goto noBSDFerr;
                        if (bsdf->rf)
                                printf("Peak front hemispherical reflectance: %.3e\n",
                                                bsdf->rLambFront.cieY +
                                                bsdf->rf->maxHemi);
                        if (bsdf->rb)
                                printf("Peak back hemispherical reflectance: %.3e\n",
                                                bsdf->rLambBack.cieY +
                                                bsdf->rb->maxHemi);
                        if (bsdf->tf)
                                printf("Peak front hemispherical transmittance: %.3e\n",
                                                bsdf->tLambFront.cieY + bsdf->tf->maxHemi);
                        if (bsdf->tb)
                                printf("Peak back hemispherical transmittance: %.3e\n",
                                                bsdf->tLambBack.cieY + bsdf->tb->maxHemi);
                        printXYZ("Diffuse Front Reflectance: ", &bsdf->rLambFront);
                        printXYZ("Diffuse Back Reflectance: ", &bsdf->rLambBack);
                        printXYZ("Diffuse Front Transmittance: ", &bsdf->tLambFront);
                        printXYZ("Diffuse Back Transmittance: ", &bsdf->tLambBack);
                        break;
                case 'Q':                       /* query BSDF value */
                        if (!bsdf)
                                goto noBSDFerr;
                        if (!*sskip2(cp,4))
                                break;
                        vec_from_deg(vin, atof(sskip2(cp,1)), atof(sskip2(cp,2)));
                        vec_from_deg(vout, atof(sskip2(cp,3)), atof(sskip2(cp,4)));
                        if (!SDreportError(SDevalBSDF(&val, vin, vout, bsdf), stderr))
                                printXYZ("", &val);
                        break;
                case 'S':                       /* sample BSDF */
                        if (!bsdf)
                                goto noBSDFerr;
                        if (!*sskip2(cp,3))
                                break;
                        if (toupper(cp[1]) == 'R') {
                                sflags &= ~SDsampT;
                                ++cp;
                        } else if (toupper(cp[1]) == 'T') {
                                sflags &= ~SDsampR;
                                ++cp;
                        }
                        if (toupper(cp[1]) == 'S')
                                sflags &= ~SDsampDf;
                        else if (toupper(cp[1]) == 'D')
                                sflags &= ~SDsampSp;
                        i = n = atoi(sskip2(cp,1));
                        vec_from_deg(vin, atof(sskip2(cp,2)), atof(sskip2(cp,3)));
                        while (i-- > 0) {
                                VCOPY(vout, vin);
                                if (SDreportError(SDsampBSDF(&val, vout,
                                                (i+rand()*(1./(RAND_MAX+.5)))/(double)n,
                                                sflags, bsdf), stderr))
                                        break;
                                printf("%.8f %.8f %.8f ", vout[0], vout[1], vout[2]);
                                printXYZ("", &val);
                        }
                        break;
                case 'H':                       /* hemispherical values */
                case 'R':
                case 'T':
                        if (!bsdf)
                                goto noBSDFerr;
                        if (!*sskip2(cp,2))
                                break;
                        if (toupper(cp[0]) == 'R')
                                sflags &= ~SDsampT;
                        else if (toupper(cp[0]) == 'T')
                                sflags &= ~SDsampR;
                        if (toupper(cp[1]) == 'S')
                                sflags &= ~SDsampDf;
                        else if (toupper(cp[1]) == 'D')
                                sflags &= ~SDsampSp;
                        vec_from_deg(vin, atof(sskip2(cp,1)), atof(sskip2(cp,2)));
                        printf("%.4e\n", SDdirectHemi(vin, sflags, bsdf));
                        break;
                case 'A':                       /* resolution in proj. steradians */
                        if (!bsdf)
                                goto noBSDFerr;
                        if (!*sskip2(cp,2))
                                break;
                        vec_from_deg(vin, atof(sskip2(cp,1)), atof(sskip2(cp,2)));
                        if (*sskip2(cp,4)) {
                                vec_from_deg(vout, atof(sskip2(cp,3)), atof(sskip2(cp,4)));
                                if (SDreportError(SDsizeBSDF(proja, vout, vin,
                                                SDqueryMin+SDqueryMax, bsdf), stderr))
                                        continue;
                        } else if (SDreportError(SDsizeBSDF(proja, vin, NULL,
                                                SDqueryMin+SDqueryMax, bsdf), stderr))
                                        continue;
                        printf("%.4e %.4e\n", proja[0], proja[1]);
                        break;
                default:
                        Usage(argv[0]);
                        break;
                }
                fflush(stdout);                 /* in case we're on remote */
                continue;
noBSDFerr:
                fprintf(stderr, "%s: First, use 'L' command to load BSDF\n", argv[0]);
        }
        return 0;
}
Revision:	1.17
Committed:	Tue Dec 7 23:49:50 2021 UTC (3 years, 10 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad5R4, rad6R0, HEAD
Changes since 1.16:	+2 -2 lines
Log Message:	fix: Repaired issue with reciprocity and BSDF sampling, thanks to Jon Sargent
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	1.17	static const char RCSid[] = "$Id: testBSDF.c,v 1.16 2021/03/27 17:50:18 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* Simple test program to demonstrate BSDF operation.
6			*
7			* G. Ward June 2015
8			*/
9
10			#define _USE_MATH_DEFINES
11			#include <stdlib.h>
12			#include <math.h>
13			#include <ctype.h>
14			#include "rtio.h"
15			#include "bsdf.h"
16
17			static void
18			Usage(const char *prog)
19			{
20			printf("Usage: %s [bsdf_directory]\n", prog);
21			printf("Input commands:\n");
22	greg	1.5	printf(" L bsdf.xml\t\t\t Load (make active) given BSDF input file\n");
23	greg	1.6	printf(" i\t\t\t\t Report general information (metadata)\n");
24			printf(" c\t\t\t\t Report diffuse and specular components\n");
25	greg	1.5	printf(" q theta_i phi_i theta_o phi_o\t Query BSDF for given path (CIE-XYZ)\n");
26	greg	1.10	printf(" s[r\|t][s\|d] N theta phi\t Generate N ray directions & colors at given incidence\n");
27			printf(" h[s\|d] theta phi\t\t Report hemispherical scattering at given incidence\n");
28			printf(" r[s\|d] theta phi\t\t Report hemispherical reflection at given incidence\n");
29			printf(" t[s\|d] theta phi\t\t Report hemispherical transmission at given incidence\n");
30	greg	1.1	printf(" a theta phi [t2 p2]\t\t Report resolution (in proj. steradians) for given direction(s)\n");
31			printf(" ^D\t\t\t\t Quit program\n");
32			}
33
34			static void
35			vec_from_deg(FVECT v, double theta, double phi)
36			{
37			const double DEG = M_PI/180.;
38
39			theta = DEG; phi = DEG;
40			v[0] = v[1] = sin(theta);
41			v[0] *= cos(phi);
42			v[1] *= sin(phi);
43			v[2] = cos(theta);
44			}
45
46	greg	1.6	static void
47			printXYZ(const char intro, const SDValue vp)
48			{
49	greg	1.11	if (vp->cieY <= 1e-9) {
50			printf("%s0 0 0\n", intro);
51			return;
52			}
53	greg	1.6	printf("%s%.3e %.3e %.3e\n", intro,
54			vp->spec.cx/vp->spec.cy*vp->cieY,
55			vp->cieY,
56			(1.-vp->spec.cx-vp->spec.cy)/
57			vp->spec.cy*vp->cieY);
58			}
59
60	greg	1.1	int
61			main(int argc, char *argv[])
62			{
63	greg	1.3	const char *directory = NULL;
64	greg	1.1	char inp[512], path[512];
65			const SDData *bsdf = NULL;
66
67			if (argc > 2 \|\| (argc == 2 && argv[1][0] == '-')) {
68			Usage(argv[0]);
69			return 1;
70			}
71			if (argc == 2)
72			directory = argv[1];
73
74	greg	1.3	SDretainSet = SDretainBSDFs; /* keep BSDFs in memory */
75	greg	1.1
76			/* loop on command */
77	greg	1.8	while (fgets(inp, sizeof(inp), stdin)) {
78	greg	1.1	int sflags = SDsampAll;
79			char *cp = inp;
80			char *cp2;
81			FVECT vin, vout;
82			double proja[2];
83	greg	1.9	int n, i;
84	greg	1.1	SDValue val;
85
86			while (isspace(*cp)) cp++;
87
88	greg	1.4	switch (toupper(*cp)) {
89	greg	1.1	case 'L': /* load/activate BSDF input */
90			cp2 = cp = sskip2(cp, 1);
91			if (!*cp)
92			break;
93			while (*cp) cp++;
94			while (isspace(--cp)) cp = '\0';
95	greg	1.3	if (directory)
96	greg	1.1	sprintf(path, "%s/%s", directory, cp2);
97			else
98			strcpy(path, cp2);
99	greg	1.3	if (bsdf)
100	greg	1.2	SDfreeCache(bsdf);
101	greg	1.1	bsdf = SDcacheFile(path);
102			continue;
103	greg	1.6	case 'I': /* report general info. */
104	greg	1.8	if (!bsdf)
105	greg	1.6	goto noBSDFerr;
106			printf("Material: '%s'\n", bsdf->matn);
107			printf("Manufacturer: '%s'\n", bsdf->makr);
108			printf("Width, Height, Thickness (m): %.4e, %.4e, %.4e\n",
109			bsdf->dim[0], bsdf->dim[1], bsdf->dim[2]);
110	greg	1.13	if (bsdf->mgf)
111			printf("Has geometry: %lu bytes\n",
112			(unsigned long)strlen(bsdf->mgf));
113			else
114			printf("Has geometry: no\n");
115	greg	1.14	break;
116	greg	1.6	case 'C': /* report constant values */
117	greg	1.8	if (!bsdf)
118	greg	1.6	goto noBSDFerr;
119	greg	1.8	if (bsdf->rf)
120	greg	1.6	printf("Peak front hemispherical reflectance: %.3e\n",
121			bsdf->rLambFront.cieY +
122			bsdf->rf->maxHemi);
123	greg	1.8	if (bsdf->rb)
124	greg	1.6	printf("Peak back hemispherical reflectance: %.3e\n",
125			bsdf->rLambBack.cieY +
126			bsdf->rb->maxHemi);
127	greg	1.8	if (bsdf->tf)
128	greg	1.6	printf("Peak front hemispherical transmittance: %.3e\n",
129	greg	1.16	bsdf->tLambFront.cieY + bsdf->tf->maxHemi);
130	greg	1.8	if (bsdf->tb)
131	greg	1.6	printf("Peak back hemispherical transmittance: %.3e\n",
132	greg	1.16	bsdf->tLambBack.cieY + bsdf->tb->maxHemi);
133	greg	1.6	printXYZ("Diffuse Front Reflectance: ", &bsdf->rLambFront);
134			printXYZ("Diffuse Back Reflectance: ", &bsdf->rLambBack);
135	greg	1.16	printXYZ("Diffuse Front Transmittance: ", &bsdf->tLambFront);
136			printXYZ("Diffuse Back Transmittance: ", &bsdf->tLambBack);
137	greg	1.14	break;
138	greg	1.1	case 'Q': /* query BSDF value */
139	greg	1.8	if (!bsdf)
140	greg	1.1	goto noBSDFerr;
141			if (!*sskip2(cp,4))
142			break;
143			vec_from_deg(vin, atof(sskip2(cp,1)), atof(sskip2(cp,2)));
144			vec_from_deg(vout, atof(sskip2(cp,3)), atof(sskip2(cp,4)));
145	greg	1.17	if (!SDreportError(SDevalBSDF(&val, vin, vout, bsdf), stderr))
146	greg	1.6	printXYZ("", &val);
147	greg	1.14	break;
148	greg	1.1	case 'S': /* sample BSDF */
149	greg	1.8	if (!bsdf)
150	greg	1.1	goto noBSDFerr;
151			if (!*sskip2(cp,3))
152			break;
153	greg	1.9	if (toupper(cp[1]) == 'R') {
154			sflags &= ~SDsampT;
155			++cp;
156			} else if (toupper(cp[1]) == 'T') {
157			sflags &= ~SDsampR;
158			++cp;
159			}
160			if (toupper(cp[1]) == 'S')
161			sflags &= ~SDsampDf;
162			else if (toupper(cp[1]) == 'D')
163			sflags &= ~SDsampSp;
164			i = n = atoi(sskip2(cp,1));
165	greg	1.1	vec_from_deg(vin, atof(sskip2(cp,2)), atof(sskip2(cp,3)));
166	greg	1.9	while (i-- > 0) {
167			VCOPY(vout, vin);
168			if (SDreportError(SDsampBSDF(&val, vout,
169			(i+rand()*(1./(RAND_MAX+.5)))/(double)n,
170	greg	1.1	sflags, bsdf), stderr))
171			break;
172	greg	1.9	printf("%.8f %.8f %.8f ", vout[0], vout[1], vout[2]);
173			printXYZ("", &val);
174	greg	1.1	}
175	greg	1.14	break;
176	greg	1.9	case 'H': /* hemispherical values */
177	greg	1.1	case 'R':
178			case 'T':
179	greg	1.8	if (!bsdf)
180	greg	1.1	goto noBSDFerr;
181			if (!*sskip2(cp,2))
182			break;
183	greg	1.9	if (toupper(cp[0]) == 'R')
184	greg	1.3	sflags &= ~SDsampT;
185	greg	1.9	else if (toupper(cp[0]) == 'T')
186	greg	1.3	sflags &= ~SDsampR;
187	greg	1.9	if (toupper(cp[1]) == 'S')
188			sflags &= ~SDsampDf;
189			else if (toupper(cp[1]) == 'D')
190			sflags &= ~SDsampSp;
191	greg	1.1	vec_from_deg(vin, atof(sskip2(cp,1)), atof(sskip2(cp,2)));
192			printf("%.4e\n", SDdirectHemi(vin, sflags, bsdf));
193	greg	1.14	break;
194	greg	1.3	case 'A': /* resolution in proj. steradians */
195	greg	1.8	if (!bsdf)
196	greg	1.1	goto noBSDFerr;
197			if (!*sskip2(cp,2))
198			break;
199			vec_from_deg(vin, atof(sskip2(cp,1)), atof(sskip2(cp,2)));
200			if (*sskip2(cp,4)) {
201			vec_from_deg(vout, atof(sskip2(cp,3)), atof(sskip2(cp,4)));
202	greg	1.12	if (SDreportError(SDsizeBSDF(proja, vout, vin,
203	greg	1.1	SDqueryMin+SDqueryMax, bsdf), stderr))
204			continue;
205			} else if (SDreportError(SDsizeBSDF(proja, vin, NULL,
206			SDqueryMin+SDqueryMax, bsdf), stderr))
207			continue;
208			printf("%.4e %.4e\n", proja[0], proja[1]);
209	greg	1.14	break;
210			default:
211			Usage(argv[0]);
212			break;
213	greg	1.1	}
214	greg	1.14	fflush(stdout); /* in case we're on remote */
215	greg	1.1	continue;
216			noBSDFerr:
217	greg	1.6	fprintf(stderr, "%s: First, use 'L' command to load BSDF\n", argv[0]);
218	greg	1.1	}
219			return 0;
220			}