src/cv/bsdfquery.c

#ifndef lint
static const char RCSid[] = "$Id: bsdfquery.c,v 2.10 2019/06/11 16:09:40 greg Exp $";
#endif
/*
 *  Query values from the given BSDF (scattering interpolant or XML repres.)
 *  Input query is incident and exiting vectors directed away from surface.
 *  We normalize.  Output is a BSDF value for the vector pair.
 *  A zero length in or out vector is ignored, causing output to be flushed.
 *  It is wise to sort the input directions to keep identical ones together
 *  when using a scattering interpolant representation.
 */

#define _USE_MATH_DEFINES
#include <stdlib.h>
#include "rtmath.h"
#include "rtio.h"
#include "bsdfrep.h"

char    *progname;

/* Read in a vector pair */
static int
readIOdir(FVECT idir, FVECT odir, FILE *fp, int fmt)
{
        double  dvec[6];
        float   fvec[6];
tryagain:
        switch (fmt) {
        case 'a':
                if (fscanf(fp, FVFORMAT, &idir[0], &idir[1], &idir[2]) != 3 ||
                                fscanf(fp, FVFORMAT, &odir[0], &odir[1], &odir[2]) != 3)
                        return(0);
                break;
        case 'd':
                if (getbinary(dvec, sizeof(double), 6, fp) != 6)
                        return(0);
                VCOPY(idir, dvec);
                VCOPY(odir, dvec+3);
                break;
        case 'f':
                if (getbinary(fvec, sizeof(float), 6, fp) != 6)
                        return(0);
                VCOPY(idir, fvec);
                VCOPY(odir, fvec+3);
                break;
        }
        if ((normalize(idir) == 0) | (normalize(odir) == 0)) {
                fflush(stdout);         /* desired side-effect? */
                goto tryagain;
        }
        return(1);
}

/* Get BSDF values for the input and output directions given on stdin */
int
main(int argc, char *argv[])
{
        int     unbuffered = 0;
        int     repXYZ = 0;
        int     inpXML = -1;
        int     inpfmt = 'a';
        int     outfmt = 'a';
        RBFNODE *rbf = NULL;
        int32   prevInpDir = 0;
        SDData  myBSDF;
        FVECT   idir, odir;
        int     n;
                                                /* check arguments */
        progname = argv[0];
        while (argc > 2 && argv[1][0] == '-') {
                switch (argv[1][1]) {
                case 'u':                       /* unbuffered output */\
                        unbuffered = 1;
                        break;
                case 'c':                       /* color output */
                        repXYZ = 1;
                        break;
                case 'f':                       /* i/o format */
                        if (!argv[1][2] || strchr("afd", argv[1][2]) == NULL)
                                goto userr;
                        inpfmt = outfmt = argv[1][2];
                        if (argv[1][3] && strchr("afd", argv[1][3]) != NULL)
                                outfmt = argv[1][3];
                        break;
                default:
                        goto userr;
                }
                ++argv; --argc;
        }
        if (argc > 1 && (n = strlen(argv[1])-4) > 0) {
                if (!strcasecmp(argv[1]+n, ".xml"))
                        inpXML = 1;
                else if (!strcasecmp(argv[1]+n, ".sir"))
                        inpXML = 0;
        }
        if ((argc != 2) | (inpXML < 0))
                goto userr;
                                                /* load BSDF representation */
        if (inpXML) {
                SDclearBSDF(&myBSDF, argv[1]);
                if (SDreportError(SDloadFile(&myBSDF, argv[1]), stderr))
                        return(1);
        } else {
                FILE    *fp = fopen(argv[1], "rb");
                if (fp == NULL) {
                        fprintf(stderr, "%s: cannot open BSDF interpolant '%s'\n",
                                        progname, argv[1]);
                        return(1);
                }
                if (!load_bsdf_rep(fp))
                        return(1);
                fclose(fp);
        }
                                                /* query BSDF values */
        while (readIOdir(idir, odir, stdin, inpfmt)) {
                SDValue sval;
                if (inpXML) {
                        if (SDreportError(SDevalBSDF(&sval, odir,
                                                idir, &myBSDF), stderr))
                                return(1);
                } else {
                        int32   inpDir = encodedir(idir);
                        if (inpDir != prevInpDir) {
                                if (idir[2] > 0 ^ input_orient > 0) {
                                        fprintf(stderr, "%s: input hemisphere error\n",
                                                        progname);
                                        return(1);
                                }
                                if (rbf != NULL) free(rbf);
                                rbf = advect_rbf(idir, 15000);
                                prevInpDir = inpDir;
                        }
                        if (odir[2] > 0 ^ output_orient > 0) {
                                fprintf(stderr, "%s: output hemisphere error\n",
                                                progname);
                                return(1);
                        }
                        if (SDreportError(eval_rbfcol(&sval, rbf, odir), stderr))
                                return(1);
                }

                switch (outfmt) {               /* write to stdout */
                case 'a':
                        if (repXYZ) {
                                double  cieX = sval.spec.cx/sval.spec.cy*sval.cieY;
                                double  cieZ = (1. - sval.spec.cx - sval.spec.cy) /
                                                sval.spec.cy * sval.cieY;
                                printf("%.6e %.6e %.6e\n", cieX, sval.cieY, cieZ);
                        } else
                                printf("%.6e\n", sval.cieY);
                        break;
                case 'd':
                        if (repXYZ) {
                                double  cieXYZ[3];
                                cieXYZ[0] = sval.spec.cx/sval.spec.cy*sval.cieY;
                                cieXYZ[1] = sval.cieY;
                                cieXYZ[2] = (1. - sval.spec.cx - sval.spec.cy) /
                                                sval.spec.cy * sval.cieY;
                                putbinary(cieXYZ, sizeof(double), 3, stdout);
                        } else
                                putbinary(&sval.cieY, sizeof(double), 1, stdout);
                        break;
                case 'f':
                        if (repXYZ) {
                                float   cieXYZ[3];
                                cieXYZ[0] = sval.spec.cx/sval.spec.cy*sval.cieY;
                                cieXYZ[1] = sval.cieY;
                                cieXYZ[2] = (1. - sval.spec.cx - sval.spec.cy) /
                                                sval.spec.cy * sval.cieY;
                                putbinary(cieXYZ, sizeof(float), 3, stdout);
                        } else {
                                float   cieY = sval.cieY;
                                putbinary(&cieY, sizeof(float), 1, stdout);
                        }
                        break;
                }
                if (unbuffered)
                        fflush(stdout);
        }
        /* if (rbf != NULL) free(rbf); */
        return(0);
userr:
        fprintf(stderr, "Usage: %s [-u][-c][-fio] bsdf.{sir|xml}\n", progname);
        return(1);
}
Revision:	2.11
Committed:	Sat Dec 28 18:05:14 2019 UTC (4 years, 4 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad5R3
Changes since 2.10:	+1 -3 lines
Log Message:	Removed redundant include files
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.11	static const char RCSid[] = "$Id: bsdfquery.c,v 2.10 2019/06/11 16:09:40 greg Exp $";
3	greg	2.1	#endif
4			/*
5			* Query values from the given BSDF (scattering interpolant or XML repres.)
6			* Input query is incident and exiting vectors directed away from surface.
7			* We normalize. Output is a BSDF value for the vector pair.
8	greg	2.9	* A zero length in or out vector is ignored, causing output to be flushed.
9	greg	2.1	* It is wise to sort the input directions to keep identical ones together
10			* when using a scattering interpolant representation.
11			*/
12
13			#define _USE_MATH_DEFINES
14			#include <stdlib.h>
15			#include "rtmath.h"
16	greg	2.7	#include "rtio.h"
17	greg	2.1	#include "bsdfrep.h"
18
19			char *progname;
20
21			/* Read in a vector pair */
22			static int
23			readIOdir(FVECT idir, FVECT odir, FILE *fp, int fmt)
24			{
25			double dvec[6];
26			float fvec[6];
27	greg	2.9	tryagain:
28	greg	2.1	switch (fmt) {
29			case 'a':
30	greg	2.5	if (fscanf(fp, FVFORMAT, &idir[0], &idir[1], &idir[2]) != 3 \|\|
31			fscanf(fp, FVFORMAT, &odir[0], &odir[1], &odir[2]) != 3)
32	greg	2.1	return(0);
33			break;
34			case 'd':
35	greg	2.7	if (getbinary(dvec, sizeof(double), 6, fp) != 6)
36	greg	2.1	return(0);
37			VCOPY(idir, dvec);
38			VCOPY(odir, dvec+3);
39			break;
40			case 'f':
41	greg	2.7	if (getbinary(fvec, sizeof(float), 6, fp) != 6)
42	greg	2.1	return(0);
43			VCOPY(idir, fvec);
44			VCOPY(odir, fvec+3);
45			break;
46			}
47			if ((normalize(idir) == 0) \| (normalize(odir) == 0)) {
48	greg	2.9	fflush(stdout); /* desired side-effect? */
49			goto tryagain;
50	greg	2.1	}
51			return(1);
52			}
53
54			/* Get BSDF values for the input and output directions given on stdin */
55			int
56			main(int argc, char *argv[])
57			{
58	greg	2.10	int unbuffered = 0;
59	greg	2.6	int repXYZ = 0;
60	greg	2.1	int inpXML = -1;
61			int inpfmt = 'a';
62			int outfmt = 'a';
63			RBFNODE *rbf = NULL;
64			int32 prevInpDir = 0;
65			SDData myBSDF;
66			FVECT idir, odir;
67			int n;
68			/* check arguments */
69			progname = argv[0];
70	greg	2.6	while (argc > 2 && argv[1][0] == '-') {
71			switch (argv[1][1]) {
72	greg	2.10	case 'u': /* unbuffered output */\
73			unbuffered = 1;
74			break;
75	greg	2.6	case 'c': /* color output */
76			repXYZ = 1;
77			break;
78			case 'f': /* i/o format */
79			if (!argv[1][2] \|\| strchr("afd", argv[1][2]) == NULL)
80			goto userr;
81			inpfmt = outfmt = argv[1][2];
82			if (argv[1][3] && strchr("afd", argv[1][3]) != NULL)
83			outfmt = argv[1][3];
84			break;
85			default:
86			goto userr;
87			}
88	greg	2.1	++argv; --argc;
89			}
90	greg	2.2	if (argc > 1 && (n = strlen(argv[1])-4) > 0) {
91	greg	2.1	if (!strcasecmp(argv[1]+n, ".xml"))
92			inpXML = 1;
93			else if (!strcasecmp(argv[1]+n, ".sir"))
94			inpXML = 0;
95			}
96	greg	2.6	if ((argc != 2) \| (inpXML < 0))
97			goto userr;
98	greg	2.1	/* load BSDF representation */
99			if (inpXML) {
100			SDclearBSDF(&myBSDF, argv[1]);
101			if (SDreportError(SDloadFile(&myBSDF, argv[1]), stderr))
102			return(1);
103			} else {
104			FILE *fp = fopen(argv[1], "rb");
105			if (fp == NULL) {
106			fprintf(stderr, "%s: cannot open BSDF interpolant '%s'\n",
107			progname, argv[1]);
108			return(1);
109			}
110			if (!load_bsdf_rep(fp))
111			return(1);
112			fclose(fp);
113			}
114			/* query BSDF values */
115			while (readIOdir(idir, odir, stdin, inpfmt)) {
116	greg	2.6	SDValue sval;
117	greg	2.1	if (inpXML) {
118			if (SDreportError(SDevalBSDF(&sval, odir,
119			idir, &myBSDF), stderr))
120			return(1);
121			} else {
122			int32 inpDir = encodedir(idir);
123			if (inpDir != prevInpDir) {
124			if (idir[2] > 0 ^ input_orient > 0) {
125			fprintf(stderr, "%s: input hemisphere error\n",
126			progname);
127			return(1);
128			}
129			if (rbf != NULL) free(rbf);
130			rbf = advect_rbf(idir, 15000);
131			prevInpDir = inpDir;
132			}
133			if (odir[2] > 0 ^ output_orient > 0) {
134			fprintf(stderr, "%s: output hemisphere error\n",
135			progname);
136			return(1);
137			}
138	greg	2.6	if (SDreportError(eval_rbfcol(&sval, rbf, odir), stderr))
139			return(1);
140	greg	2.1	}
141	greg	2.6
142	greg	2.1	switch (outfmt) { /* write to stdout */
143			case 'a':
144	greg	2.6	if (repXYZ) {
145			double cieX = sval.spec.cx/sval.spec.cy*sval.cieY;
146			double cieZ = (1. - sval.spec.cx - sval.spec.cy) /
147			sval.spec.cy * sval.cieY;
148			printf("%.6e %.6e %.6e\n", cieX, sval.cieY, cieZ);
149			} else
150			printf("%.6e\n", sval.cieY);
151	greg	2.1	break;
152			case 'd':
153	greg	2.6	if (repXYZ) {
154			double cieXYZ[3];
155			cieXYZ[0] = sval.spec.cx/sval.spec.cy*sval.cieY;
156			cieXYZ[1] = sval.cieY;
157			cieXYZ[2] = (1. - sval.spec.cx - sval.spec.cy) /
158			sval.spec.cy * sval.cieY;
159	greg	2.7	putbinary(cieXYZ, sizeof(double), 3, stdout);
160	greg	2.6	} else
161	greg	2.7	putbinary(&sval.cieY, sizeof(double), 1, stdout);
162	greg	2.1	break;
163			case 'f':
164	greg	2.6	if (repXYZ) {
165			float cieXYZ[3];
166			cieXYZ[0] = sval.spec.cx/sval.spec.cy*sval.cieY;
167			cieXYZ[1] = sval.cieY;
168			cieXYZ[2] = (1. - sval.spec.cx - sval.spec.cy) /
169			sval.spec.cy * sval.cieY;
170	greg	2.7	putbinary(cieXYZ, sizeof(float), 3, stdout);
171	greg	2.6	} else {
172			float cieY = sval.cieY;
173	greg	2.7	putbinary(&cieY, sizeof(float), 1, stdout);
174	greg	2.6	}
175	greg	2.1	break;
176			}
177	greg	2.10	if (unbuffered)
178			fflush(stdout);
179	greg	2.1	}
180	greg	2.6	/* if (rbf != NULL) free(rbf); */
181	greg	2.1	return(0);
182	greg	2.6	userr:
183	greg	2.10	fprintf(stderr, "Usage: %s [-u][-c][-fio] bsdf.{sir\|xml}\n", progname);
184	greg	2.6	return(1);
185	greg	2.1	}