src/cv/bsdfquery.c

#ifndef lint
static const char RCSid[] = "$Id: bsdfquery.c,v 2.13 2025/06/03 21:31:51 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"

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