src/cv/bsdf2ttree.c

#ifndef lint
static const char RCSid[] = "$Id: bsdf2ttree.c,v 2.31 2016/01/29 16:21:55 greg Exp $";
#endif
/*
 * Load measured BSDF interpolant and write out as XML file with tensor tree.
 *
 *      G. Ward
 */

#define _USE_MATH_DEFINES
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "random.h"
#include "platform.h"
#include "rtprocess.h"
#include "calcomp.h"
#include "bsdfrep.h"
                                /* global argv[0] */
char                    *progname;
                                /* percentage to cull (<0 to turn off) */
static double           pctcull = 90.;
                                /* sampling order */
static int              samp_order = 6;
                                /* super-sampling threshold */
const double            ssamp_thresh = 0.35;
                                /* number of super-samples */
#ifndef NSSAMP
#define NSSAMP          100
#endif
                                /* limit on number of RBF lobes */
static int              lobe_lim = 15000;
                                /* progress bar length */
static int              do_prog = 79;


/* Start new progress bar */
#define prog_start(s)   if (do_prog) fprintf(stderr, "%s: %s...\n", progname, s); else

/* Draw progress bar of the appropriate length */
static void
prog_show(double frac)
{
        static unsigned call_cnt = 0;
        static char     lastc[] = "-\\|/";
        char            pbar[256];
        int             nchars;

        if (do_prog <= 1) return;
        if (do_prog > sizeof(pbar)-2)
                do_prog = sizeof(pbar)-2;
        if (frac < 0) frac = 0;
        else if (frac >= 1) frac = .9999;
        nchars = do_prog*frac;
        pbar[0] = '\r';
        memset(pbar+1, '*', nchars);
        pbar[nchars+1] = lastc[call_cnt++ & 3];
        memset(pbar+2+nchars, '-', do_prog-nchars-1);
        pbar[do_prog+1] = '\0';
        fputs(pbar, stderr);
}

/* Finish progress bar */
static void
prog_done(void)
{
        int     n = do_prog;

        if (n <= 1) return;
        fputc('\r', stderr);
        while (n--)
                fputc(' ', stderr);
        fputc('\r', stderr);
}

/* Compute absolute relative difference */
static double
abs_diff(double v1, double v0)
{
        if ((v0 < 0) | (v1 < 0))
                return(.0);
        v1 = (v1-v0)*2./(v0+v1+.0001);
        if (v1 < 0)
                return(-v1);
        return(v1);
}

/* Interpolate and output isotropic BSDF data */
static void
eval_isotropic(char *funame)
{
        const int       sqres = 1<<samp_order;
        FILE            *ofp = NULL;
        int             assignD = 0;
        char            cmd[128];
        int             ix, ox, oy;
        double          iovec[6];
        float           bsdf;

        data_prologue();                        /* begin output */
        if (pctcull >= 0) {
                sprintf(cmd, "rttree_reduce -a -h -ff -r 3 -t %f -g %d",
                                pctcull, samp_order);
                fflush(stdout);
                ofp = popen(cmd, "w");
                if (ofp == NULL) {
                        fprintf(stderr, "%s: cannot create pipe to rttree_reduce\n",
                                        progname);
                        exit(1);
                }
                SET_FILE_BINARY(ofp);
#ifdef getc_unlocked                            /* avoid lock/unlock overhead */
                flockfile(ofp);
#endif
        } else
                fputs("{\n", stdout);
                                                /* need to assign Dx, Dy, Dz? */
        if (funame != NULL)
                assignD = (fundefined(funame) < 6);
                                                /* run through directions */
        for (ix = 0; ix < sqres/2; ix++) {
                RBFNODE *rbf = NULL;
                iovec[0] = 2.*(ix+.5)/sqres - 1.;
                iovec[1] = .0;
                iovec[2] = input_orient * sqrt(1. - iovec[0]*iovec[0]);
                if (funame == NULL)
                        rbf = advect_rbf(iovec, lobe_lim);
                for (ox = 0; ox < sqres; ox++) {
                    float       last_bsdf = -1;
                    for (oy = 0; oy < sqres; oy++) {
                        SDsquare2disk(iovec+3, (ox+.5)/sqres, (oy+.5)/sqres);
                        iovec[5] = output_orient *
                                sqrt(1. - iovec[3]*iovec[3] - iovec[4]*iovec[4]);
                        if (funame == NULL)
                            bsdf = eval_rbfrep(rbf, iovec+3);
                        else {
                            if (assignD) {
                                varset("Dx", '=', -iovec[3]);
                                varset("Dy", '=', -iovec[4]);
                                varset("Dz", '=', -iovec[5]);
                                ++eclock;
                            }
                            bsdf = funvalue(funame, 6, iovec);
#if (NSSAMP > 0)
                            if (abs_diff(bsdf, last_bsdf) > ssamp_thresh) {
                                int     ssi;
                                double  ssa[3], ssvec[6], sum = 0;
                                                /* super-sample voxel */
                                for (ssi = NSSAMP; ssi--; ) {
                                    SDmultiSamp(ssa, 3, (ssi+frandom()) *
                                                        (1./NSSAMP));
                                    ssvec[0] = 2.*(ix+ssa[0])/sqres - 1.;
                                    ssvec[1] = .0;
                                    ssvec[2] = input_orient *
                                                sqrt(1. - ssvec[0]*ssvec[0]);
                                    SDsquare2disk(ssvec+3, (ox+ssa[1])/sqres,
                                                (oy+ssa[2])/sqres);
                                    ssvec[5] = output_orient *
                                                sqrt(1. - ssvec[3]*ssvec[3] -
                                                        ssvec[4]*ssvec[4]);
                                    if (assignD) {
                                        varset("Dx", '=', -ssvec[3]);
                                        varset("Dy", '=', -ssvec[4]);
                                        varset("Dz", '=', -ssvec[5]);
                                        ++eclock;
                                    }
                                    sum += funvalue(funame, 6, ssvec);
                                }
                                bsdf = sum/NSSAMP;
                            }
#endif
                        }
                        if (pctcull >= 0)
                                fwrite(&bsdf, sizeof(bsdf), 1, ofp);
                        else
                                printf("\t%.3e\n", bsdf);
                        last_bsdf = bsdf;
                    }
                }
                if (rbf != NULL)
                        free(rbf);
                prog_show((ix+1.)*(2./sqres));
        }
        if (pctcull >= 0) {                     /* finish output */
                if (pclose(ofp)) {
                        fprintf(stderr, "%s: error running '%s'\n",
                                        progname, cmd);
                        exit(1);
                }
        } else {
                for (ix = sqres*sqres*sqres/2; ix--; )
                        fputs("\t0\n", stdout);
                fputs("}\n", stdout);
        }
        data_epilogue();
        prog_done();
}

/* Interpolate and output anisotropic BSDF data */
static void
eval_anisotropic(char *funame)
{
        const int       sqres = 1<<samp_order;
        FILE            *ofp = NULL;
        int             assignD = 0;
        char            cmd[128];
        int             ix, iy, ox, oy;
        double          iovec[6];
        float           bsdf;

        data_prologue();                        /* begin output */
        if (pctcull >= 0) {
                sprintf(cmd, "rttree_reduce%s -h -ff -r 4 -t %f -g %d",
                                (input_orient>0 ^ output_orient>0) ? "" : " -a",
                                pctcull, samp_order);
                fflush(stdout);
                ofp = popen(cmd, "w");
                if (ofp == NULL) {
                        fprintf(stderr, "%s: cannot create pipe to rttree_reduce\n",
                                        progname);
                        exit(1);
                }
                SET_FILE_BINARY(ofp);
#ifdef getc_unlocked                            /* avoid lock/unlock overhead */
                flockfile(ofp);
#endif
        } else
                fputs("{\n", stdout);
                                                /* need to assign Dx, Dy, Dz? */
        if (funame != NULL)
                assignD = (fundefined(funame) < 6);
                                                /* run through directions */
        for (ix = 0; ix < sqres; ix++)
            for (iy = 0; iy < sqres; iy++) {
                RBFNODE *rbf = NULL;            /* Klems reversal */
                SDsquare2disk(iovec, 1.-(ix+.5)/sqres, 1.-(iy+.5)/sqres);
                iovec[2] = input_orient *
                                sqrt(1. - iovec[0]*iovec[0] - iovec[1]*iovec[1]);
                if (funame == NULL)
                        rbf = advect_rbf(iovec, lobe_lim);
                for (ox = 0; ox < sqres; ox++) {
                    float       last_bsdf = -1;
                    for (oy = 0; oy < sqres; oy++) {
                        SDsquare2disk(iovec+3, (ox+.5)/sqres, (oy+.5)/sqres);
                        iovec[5] = output_orient *
                                sqrt(1. - iovec[3]*iovec[3] - iovec[4]*iovec[4]);
                        if (funame == NULL)
                            bsdf = eval_rbfrep(rbf, iovec+3);
                        else {
                            if (assignD) {
                                varset("Dx", '=', -iovec[3]);
                                varset("Dy", '=', -iovec[4]);
                                varset("Dz", '=', -iovec[5]);
                                ++eclock;
                            }
                            bsdf = funvalue(funame, 6, iovec);
#if (NSSAMP > 0)
                            if (abs_diff(bsdf, last_bsdf) > ssamp_thresh) {
                                int     ssi;
                                double  ssa[4], ssvec[6], sum = 0;
                                                /* super-sample voxel */
                                for (ssi = NSSAMP; ssi--; ) {
                                    SDmultiSamp(ssa, 4, (ssi+frandom()) *
                                                        (1./NSSAMP));
                                    SDsquare2disk(ssvec, 1.-(ix+ssa[0])/sqres,
                                                1.-(iy+ssa[1])/sqres);
                                    ssvec[2] = input_orient *
                                                sqrt(1. - ssvec[0]*ssvec[0] -
                                                        ssvec[1]*ssvec[1]);
                                    SDsquare2disk(ssvec+3, (ox+ssa[2])/sqres,
                                                (oy+ssa[3])/sqres);
                                    ssvec[5] = output_orient *
                                                sqrt(1. - ssvec[3]*ssvec[3] -
                                                        ssvec[4]*ssvec[4]);
                                    if (assignD) {
                                        varset("Dx", '=', -ssvec[3]);
                                        varset("Dy", '=', -ssvec[4]);
                                        varset("Dz", '=', -ssvec[5]);
                                        ++eclock;
                                    }
                                    sum += funvalue(funame, 6, ssvec);
                                }
                                bsdf = sum/NSSAMP;
                            }
#endif
                        }
                        if (pctcull >= 0)
                                fwrite(&bsdf, sizeof(bsdf), 1, ofp);
                        else
                                printf("\t%.3e\n", bsdf);
                        last_bsdf = bsdf;
                    }
                }
                if (rbf != NULL)
                        free(rbf);
                prog_show((ix*sqres+iy+1.)/(sqres*sqres));
            }
        if (pctcull >= 0) {                     /* finish output */
                if (pclose(ofp)) {
                        fprintf(stderr, "%s: error running '%s'\n",
                                        progname, cmd);
                        exit(1);
                }
        } else
                fputs("}\n", stdout);
        data_epilogue();
        prog_done();
}

/* Read in BSDF and interpolate as tensor tree representation */
int
main(int argc, char *argv[])
{
        int     dofwd = 0, dobwd = 1;
        int     i, na;

        progname = argv[0];
        esupport |= E_VARIABLE|E_FUNCTION|E_RCONST;
        esupport &= ~(E_INCHAN|E_OUTCHAN);
        scompile("PI:3.14159265358979323846", NULL, 0);
        biggerlib();
        for (i = 1; i < argc-1 && (argv[i][0] == '-') | (argv[i][0] == '+'); i++)
                switch (argv[i][1]) {           /* get options */
                case 'e':
                        scompile(argv[++i], NULL, 0);
                        break;
                case 'f':
                        if (!argv[i][2])
                                fcompile(argv[++i]);
                        else
                                dofwd = (argv[i][0] == '+');
                        break;
                case 'b':
                        dobwd = (argv[i][0] == '+');
                        break;
                case 't':
                        switch (argv[i][2]) {
                        case '3':
                                single_plane_incident = 1;
                                break;
                        case '4':
                                single_plane_incident = 0;
                                break;
                        case '\0':
                                pctcull = atof(argv[++i]);
                                break;
                        default:
                                goto userr;
                        }
                        break;
                case 'g':
                        samp_order = atoi(argv[++i]);
                        break;
                case 'l':
                        lobe_lim = atoi(argv[++i]);
                        break;
                case 'p':
                        do_prog = atoi(argv[i]+2);
                        break;
                default:
                        goto userr;
                }
        if (single_plane_incident >= 0) {       /* function-based BSDF? */
                void    (*evf)(char *s) = single_plane_incident ?
                                &eval_isotropic : &eval_anisotropic;
                if (i != argc-1 || fundefined(argv[i]) < 3) {
                        fprintf(stderr,
        "%s: need single function with 6 arguments: bsdf(ix,iy,iz,ox,oy,oz)\n",
                                        progname);
                        fprintf(stderr, "\tor 3 arguments using Dx,Dy,Dz: bsdf(ix,iy,iz)\n");
                        goto userr;
                }
                ++eclock;
                xml_prologue(argc, argv);       /* start XML output */
                if (dofwd) {
                        input_orient = -1;
                        output_orient = -1;
                        prog_start("Evaluating outside reflectance");
                        (*evf)(argv[i]);
                        output_orient = 1;
                        prog_start("Evaluating outside->inside transmission");
                        (*evf)(argv[i]);
                }
                if (dobwd) {
                        input_orient = 1;
                        output_orient = 1;
                        prog_start("Evaluating inside reflectance");
                        (*evf)(argv[i]);
                        output_orient = -1;
                        prog_start("Evaluating inside->outside transmission");
                        (*evf)(argv[i]);
                }
                xml_epilogue();                 /* finish XML output & exit */
                return(0);
        }
        if (i < argc) {                         /* open input files if given */
                int     nbsdf = 0;
                for ( ; i < argc; i++) {        /* interpolate each component */
                        char    pbuf[256];
                        FILE    *fpin = fopen(argv[i], "rb");
                        if (fpin == NULL) {
                                fprintf(stderr, "%s: cannot open BSDF interpolant '%s'\n",
                                                progname, argv[i]);
                                return(1);
                        }
                        if (!load_bsdf_rep(fpin))
                                return(1);
                        fclose(fpin);
                        if (!nbsdf++)           /* start XML on first dist. */
                                xml_prologue(argc, argv);
                        sprintf(pbuf, "Interpolating component '%s'", argv[i]);
                        prog_start(pbuf);
                        if (single_plane_incident)
                                eval_isotropic(NULL);
                        else
                                eval_anisotropic(NULL);
                }
                xml_epilogue();                 /* finish XML output & exit */
                return(0);
        }
        SET_FILE_BINARY(stdin);                 /* load from stdin */
        if (!load_bsdf_rep(stdin))
                return(1);
        xml_prologue(argc, argv);               /* start XML output */
        prog_start("Interpolating from standard input");
        if (single_plane_incident)              /* resample dist. */
                eval_isotropic(NULL);
        else
                eval_anisotropic(NULL);
        xml_epilogue();                         /* finish XML output & exit */
        return(0);
userr:
        fprintf(stderr,
        "Usage: %s [-g Nlog2][-t pctcull][-l maxlobes] [bsdf.sir ..] > bsdf.xml\n",
                                progname);
        fprintf(stderr,
        "   or: %s -t{3|4} [-g Nlog2][-t pctcull][{+|-}for[ward]][{+|-}b[ackward]][-e expr][-f file] bsdf_func > bsdf.xml\n",
                                progname);
        return(1);
}
Revision:	2.32
Committed:	Tue Feb 2 18:02:32 2016 UTC (8 years, 3 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.31:	+2 -71 lines
Log Message:	Moved declaration of popen to paths.h and put convert_command() into module
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.32	static const char RCSid[] = "$Id: bsdf2ttree.c,v 2.31 2016/01/29 16:21:55 greg Exp $";
3	greg	2.1	#endif
4			/*
5			* Load measured BSDF interpolant and write out as XML file with tensor tree.
6			*
7			* G. Ward
8			*/
9
10			#define _USE_MATH_DEFINES
11			#include <stdio.h>
12			#include <stdlib.h>
13			#include <math.h>
14	greg	2.23	#include "random.h"
15	greg	2.1	#include "platform.h"
16	greg	2.22	#include "rtprocess.h"
17	greg	2.11	#include "calcomp.h"
18	greg	2.1	#include "bsdfrep.h"
19			/* global argv[0] */
20			char *progname;
21			/* percentage to cull (<0 to turn off) */
22	greg	2.31	static double pctcull = 90.;
23	greg	2.1	/* sampling order */
24	greg	2.31	static int samp_order = 6;
25	greg	2.15	/* super-sampling threshold */
26			const double ssamp_thresh = 0.35;
27			/* number of super-samples */
28	greg	2.28	#ifndef NSSAMP
29			#define NSSAMP 100
30			#endif
31	greg	2.18	/* limit on number of RBF lobes */
32			static int lobe_lim = 15000;
33	greg	2.26	/* progress bar length */
34			static int do_prog = 79;
35
36
37	greg	2.32
38	greg	2.26	/* Start new progress bar */
39			#define prog_start(s) if (do_prog) fprintf(stderr, "%s: %s...\n", progname, s); else
40
41			/* Draw progress bar of the appropriate length */
42			static void
43			prog_show(double frac)
44			{
45	greg	2.30	static unsigned call_cnt = 0;
46			static char lastc[] = "-\\\|/";
47			char pbar[256];
48			int nchars;
49	greg	2.26
50	greg	2.30	if (do_prog <= 1) return;
51	greg	2.26	if (do_prog > sizeof(pbar)-2)
52			do_prog = sizeof(pbar)-2;
53			if (frac < 0) frac = 0;
54	greg	2.30	else if (frac >= 1) frac = .9999;
55			nchars = do_prog*frac;
56	greg	2.26	pbar[0] = '\r';
57			memset(pbar+1, '*', nchars);
58	greg	2.30	pbar[nchars+1] = lastc[call_cnt++ & 3];
59			memset(pbar+2+nchars, '-', do_prog-nchars-1);
60	greg	2.26	pbar[do_prog+1] = '\0';
61			fputs(pbar, stderr);
62			}
63
64			/* Finish progress bar */
65	greg	2.27	static void
66			prog_done(void)
67			{
68			int n = do_prog;
69
70			if (n <= 1) return;
71			fputc('\r', stderr);
72			while (n--)
73			fputc(' ', stderr);
74			fputc('\r', stderr);
75			}
76	greg	2.1
77	greg	2.15	/* Compute absolute relative difference */
78			static double
79			abs_diff(double v1, double v0)
80			{
81			if ((v0 < 0) \| (v1 < 0))
82			return(.0);
83			v1 = (v1-v0)*2./(v0+v1+.0001);
84			if (v1 < 0)
85			return(-v1);
86			return(v1);
87			}
88
89	greg	2.1	/* Interpolate and output isotropic BSDF data */
90			static void
91	greg	2.11	eval_isotropic(char *funame)
92	greg	2.1	{
93			const int sqres = 1<<samp_order;
94			FILE *ofp = NULL;
95	greg	2.17	int assignD = 0;
96	greg	2.1	char cmd[128];
97			int ix, ox, oy;
98	greg	2.11	double iovec[6];
99	greg	2.4	float bsdf;
100	greg	2.15
101	greg	2.11	data_prologue(); /* begin output */
102			if (pctcull >= 0) {
103	greg	2.20	sprintf(cmd, "rttree_reduce -a -h -ff -r 3 -t %f -g %d",
104	greg	2.1	pctcull, samp_order);
105			fflush(stdout);
106			ofp = popen(cmd, "w");
107			if (ofp == NULL) {
108			fprintf(stderr, "%s: cannot create pipe to rttree_reduce\n",
109			progname);
110			exit(1);
111			}
112			SET_FILE_BINARY(ofp);
113	greg	2.25	#ifdef getc_unlocked /* avoid lock/unlock overhead */
114			flockfile(ofp);
115			#endif
116	greg	2.1	} else
117			fputs("{\n", stdout);
118	greg	2.17	/* need to assign Dx, Dy, Dz? */
119			if (funame != NULL)
120			assignD = (fundefined(funame) < 6);
121	greg	2.1	/* run through directions */
122			for (ix = 0; ix < sqres/2; ix++) {
123	greg	2.11	RBFNODE *rbf = NULL;
124	greg	2.14	iovec[0] = 2.*(ix+.5)/sqres - 1.;
125	greg	2.11	iovec[1] = .0;
126			iovec[2] = input_orient * sqrt(1. - iovec[0]*iovec[0]);
127			if (funame == NULL)
128	greg	2.18	rbf = advect_rbf(iovec, lobe_lim);
129	greg	2.15	for (ox = 0; ox < sqres; ox++) {
130			float last_bsdf = -1;
131	greg	2.1	for (oy = 0; oy < sqres; oy++) {
132	greg	2.11	SDsquare2disk(iovec+3, (ox+.5)/sqres, (oy+.5)/sqres);
133			iovec[5] = output_orient *
134			sqrt(1. - iovec[3]iovec[3] - iovec[4]iovec[4]);
135			if (funame == NULL)
136	greg	2.29	bsdf = eval_rbfrep(rbf, iovec+3);
137	greg	2.15	else {
138	greg	2.17	if (assignD) {
139			varset("Dx", '=', -iovec[3]);
140			varset("Dy", '=', -iovec[4]);
141			varset("Dz", '=', -iovec[5]);
142			++eclock;
143			}
144	greg	2.15	bsdf = funvalue(funame, 6, iovec);
145	greg	2.28	#if (NSSAMP > 0)
146	greg	2.15	if (abs_diff(bsdf, last_bsdf) > ssamp_thresh) {
147	greg	2.28	int ssi;
148			double ssa[3], ssvec[6], sum = 0;
149			/* super-sample voxel */
150			for (ssi = NSSAMP; ssi--; ) {
151			SDmultiSamp(ssa, 3, (ssi+frandom()) *
152			(1./NSSAMP));
153	greg	2.15	ssvec[0] = 2.*(ix+ssa[0])/sqres - 1.;
154			ssvec[1] = .0;
155			ssvec[2] = input_orient *
156			sqrt(1. - ssvec[0]*ssvec[0]);
157			SDsquare2disk(ssvec+3, (ox+ssa[1])/sqres,
158			(oy+ssa[2])/sqres);
159			ssvec[5] = output_orient *
160			sqrt(1. - ssvec[3]*ssvec[3] -
161			ssvec[4]*ssvec[4]);
162	greg	2.17	if (assignD) {
163	greg	2.28	varset("Dx", '=', -ssvec[3]);
164			varset("Dy", '=', -ssvec[4]);
165			varset("Dz", '=', -ssvec[5]);
166	greg	2.17	++eclock;
167			}
168	greg	2.16	sum += funvalue(funame, 6, ssvec);
169	greg	2.15	}
170	greg	2.28	bsdf = sum/NSSAMP;
171	greg	2.15	}
172	greg	2.28	#endif
173	greg	2.15	}
174	greg	2.1	if (pctcull >= 0)
175			fwrite(&bsdf, sizeof(bsdf), 1, ofp);
176			else
177			printf("\t%.3e\n", bsdf);
178	greg	2.15	last_bsdf = bsdf;
179	greg	2.1	}
180	greg	2.15	}
181	greg	2.3	if (rbf != NULL)
182			free(rbf);
183	greg	2.26	prog_show((ix+1.)*(2./sqres));
184	greg	2.1	}
185			if (pctcull >= 0) { /* finish output */
186			if (pclose(ofp)) {
187			fprintf(stderr, "%s: error running '%s'\n",
188			progname, cmd);
189			exit(1);
190			}
191			} else {
192			for (ix = sqressqressqres/2; ix--; )
193			fputs("\t0\n", stdout);
194			fputs("}\n", stdout);
195			}
196	greg	2.11	data_epilogue();
197	greg	2.26	prog_done();
198	greg	2.1	}
199
200			/* Interpolate and output anisotropic BSDF data */
201			static void
202	greg	2.11	eval_anisotropic(char *funame)
203	greg	2.1	{
204			const int sqres = 1<<samp_order;
205			FILE *ofp = NULL;
206	greg	2.17	int assignD = 0;
207	greg	2.1	char cmd[128];
208			int ix, iy, ox, oy;
209	greg	2.11	double iovec[6];
210	greg	2.4	float bsdf;
211	greg	2.15
212	greg	2.11	data_prologue(); /* begin output */
213			if (pctcull >= 0) {
214	greg	2.19	sprintf(cmd, "rttree_reduce%s -h -ff -r 4 -t %f -g %d",
215			(input_orient>0 ^ output_orient>0) ? "" : " -a",
216	greg	2.1	pctcull, samp_order);
217			fflush(stdout);
218			ofp = popen(cmd, "w");
219			if (ofp == NULL) {
220			fprintf(stderr, "%s: cannot create pipe to rttree_reduce\n",
221			progname);
222			exit(1);
223			}
224	greg	2.25	SET_FILE_BINARY(ofp);
225			#ifdef getc_unlocked /* avoid lock/unlock overhead */
226			flockfile(ofp);
227			#endif
228	greg	2.1	} else
229			fputs("{\n", stdout);
230	greg	2.17	/* need to assign Dx, Dy, Dz? */
231			if (funame != NULL)
232			assignD = (fundefined(funame) < 6);
233	greg	2.1	/* run through directions */
234			for (ix = 0; ix < sqres; ix++)
235			for (iy = 0; iy < sqres; iy++) {
236	greg	2.11	RBFNODE rbf = NULL; / Klems reversal */
237	greg	2.15	SDsquare2disk(iovec, 1.-(ix+.5)/sqres, 1.-(iy+.5)/sqres);
238	greg	2.11	iovec[2] = input_orient *
239			sqrt(1. - iovec[0]iovec[0] - iovec[1]iovec[1]);
240			if (funame == NULL)
241	greg	2.18	rbf = advect_rbf(iovec, lobe_lim);
242	greg	2.15	for (ox = 0; ox < sqres; ox++) {
243			float last_bsdf = -1;
244	greg	2.1	for (oy = 0; oy < sqres; oy++) {
245	greg	2.11	SDsquare2disk(iovec+3, (ox+.5)/sqres, (oy+.5)/sqres);
246			iovec[5] = output_orient *
247			sqrt(1. - iovec[3]iovec[3] - iovec[4]iovec[4]);
248			if (funame == NULL)
249	greg	2.29	bsdf = eval_rbfrep(rbf, iovec+3);
250	greg	2.15	else {
251	greg	2.17	if (assignD) {
252			varset("Dx", '=', -iovec[3]);
253			varset("Dy", '=', -iovec[4]);
254			varset("Dz", '=', -iovec[5]);
255			++eclock;
256			}
257	greg	2.15	bsdf = funvalue(funame, 6, iovec);
258	greg	2.28	#if (NSSAMP > 0)
259	greg	2.15	if (abs_diff(bsdf, last_bsdf) > ssamp_thresh) {
260	greg	2.28	int ssi;
261			double ssa[4], ssvec[6], sum = 0;
262			/* super-sample voxel */
263			for (ssi = NSSAMP; ssi--; ) {
264			SDmultiSamp(ssa, 4, (ssi+frandom()) *
265			(1./NSSAMP));
266	greg	2.15	SDsquare2disk(ssvec, 1.-(ix+ssa[0])/sqres,
267			1.-(iy+ssa[1])/sqres);
268	greg	2.28	ssvec[2] = input_orient *
269	greg	2.15	sqrt(1. - ssvec[0]*ssvec[0] -
270			ssvec[1]*ssvec[1]);
271			SDsquare2disk(ssvec+3, (ox+ssa[2])/sqres,
272			(oy+ssa[3])/sqres);
273			ssvec[5] = output_orient *
274			sqrt(1. - ssvec[3]*ssvec[3] -
275			ssvec[4]*ssvec[4]);
276	greg	2.17	if (assignD) {
277	greg	2.28	varset("Dx", '=', -ssvec[3]);
278			varset("Dy", '=', -ssvec[4]);
279			varset("Dz", '=', -ssvec[5]);
280	greg	2.17	++eclock;
281			}
282	greg	2.16	sum += funvalue(funame, 6, ssvec);
283	greg	2.15	}
284	greg	2.28	bsdf = sum/NSSAMP;
285	greg	2.15	}
286	greg	2.28	#endif
287	greg	2.15	}
288	greg	2.1	if (pctcull >= 0)
289			fwrite(&bsdf, sizeof(bsdf), 1, ofp);
290			else
291			printf("\t%.3e\n", bsdf);
292	greg	2.15	last_bsdf = bsdf;
293	greg	2.1	}
294	greg	2.15	}
295	greg	2.3	if (rbf != NULL)
296			free(rbf);
297	greg	2.26	prog_show((ixsqres+iy+1.)/(sqressqres));
298	greg	2.1	}
299			if (pctcull >= 0) { /* finish output */
300			if (pclose(ofp)) {
301			fprintf(stderr, "%s: error running '%s'\n",
302			progname, cmd);
303			exit(1);
304			}
305			} else
306			fputs("}\n", stdout);
307	greg	2.11	data_epilogue();
308	greg	2.26	prog_done();
309	greg	2.5	}
310
311	greg	2.1	/* Read in BSDF and interpolate as tensor tree representation */
312			int
313			main(int argc, char *argv[])
314			{
315	greg	2.11	int dofwd = 0, dobwd = 1;
316			int i, na;
317	greg	2.1
318	greg	2.5	progname = argv[0];
319	greg	2.11	esupport \|= E_VARIABLE\|E_FUNCTION\|E_RCONST;
320			esupport &= ~(E_INCHAN\|E_OUTCHAN);
321			scompile("PI:3.14159265358979323846", NULL, 0);
322			biggerlib();
323			for (i = 1; i < argc-1 && (argv[i][0] == '-') \| (argv[i][0] == '+'); i++)
324			switch (argv[i][1]) { /* get options */
325			case 'e':
326			scompile(argv[++i], NULL, 0);
327			break;
328			case 'f':
329			if (!argv[i][2])
330			fcompile(argv[++i]);
331			else
332			dofwd = (argv[i][0] == '+');
333			break;
334			case 'b':
335			dobwd = (argv[i][0] == '+');
336			break;
337	greg	2.1	case 't':
338	greg	2.11	switch (argv[i][2]) {
339			case '3':
340	greg	2.13	single_plane_incident = 1;
341	greg	2.11	break;
342			case '4':
343	greg	2.13	single_plane_incident = 0;
344	greg	2.11	break;
345			case '\0':
346			pctcull = atof(argv[++i]);
347			break;
348			default:
349			goto userr;
350			}
351	greg	2.1	break;
352			case 'g':
353	greg	2.5	samp_order = atoi(argv[++i]);
354	greg	2.1	break;
355	greg	2.18	case 'l':
356			lobe_lim = atoi(argv[++i]);
357			break;
358	greg	2.26	case 'p':
359			do_prog = atoi(argv[i]+2);
360			break;
361	greg	2.1	default:
362			goto userr;
363			}
364	greg	2.11	if (single_plane_incident >= 0) { /* function-based BSDF? */
365			void (evf)(char s) = single_plane_incident ?
366			&eval_isotropic : &eval_anisotropic;
367	greg	2.17	if (i != argc-1 \|\| fundefined(argv[i]) < 3) {
368	greg	2.12	fprintf(stderr,
369			"%s: need single function with 6 arguments: bsdf(ix,iy,iz,ox,oy,oz)\n",
370			progname);
371	greg	2.24	fprintf(stderr, "\tor 3 arguments using Dx,Dy,Dz: bsdf(ix,iy,iz)\n");
372	greg	2.11	goto userr;
373	greg	2.12	}
374	greg	2.17	++eclock;
375	greg	2.11	xml_prologue(argc, argv); /* start XML output */
376			if (dofwd) {
377			input_orient = -1;
378			output_orient = -1;
379	greg	2.26	prog_start("Evaluating outside reflectance");
380			(*evf)(argv[i]);
381	greg	2.11	output_orient = 1;
382	greg	2.26	prog_start("Evaluating outside->inside transmission");
383			(*evf)(argv[i]);
384	greg	2.11	}
385			if (dobwd) {
386			input_orient = 1;
387			output_orient = 1;
388	greg	2.26	prog_start("Evaluating inside reflectance");
389			(*evf)(argv[i]);
390	greg	2.11	output_orient = -1;
391	greg	2.26	prog_start("Evaluating inside->outside transmission");
392			(*evf)(argv[i]);
393	greg	2.11	}
394			xml_epilogue(); /* finish XML output & exit */
395			return(0);
396			}
397			if (i < argc) { /* open input files if given */
398	greg	2.12	int nbsdf = 0;
399	greg	2.11	for ( ; i < argc; i++) { /* interpolate each component */
400	greg	2.26	char pbuf[256];
401	greg	2.11	FILE *fpin = fopen(argv[i], "rb");
402			if (fpin == NULL) {
403			fprintf(stderr, "%s: cannot open BSDF interpolant '%s'\n",
404			progname, argv[i]);
405			return(1);
406			}
407			if (!load_bsdf_rep(fpin))
408			return(1);
409			fclose(fpin);
410	greg	2.12	if (!nbsdf++) /* start XML on first dist. */
411			xml_prologue(argc, argv);
412	greg	2.26	sprintf(pbuf, "Interpolating component '%s'", argv[i]);
413			prog_start(pbuf);
414	greg	2.11	if (single_plane_incident)
415			eval_isotropic(NULL);
416			else
417			eval_anisotropic(NULL);
418			}
419			xml_epilogue(); /* finish XML output & exit */
420			return(0);
421			}
422			SET_FILE_BINARY(stdin); /* load from stdin */
423			if (!load_bsdf_rep(stdin))
424	greg	2.1	return(1);
425	greg	2.5	xml_prologue(argc, argv); /* start XML output */
426	greg	2.26	prog_start("Interpolating from standard input");
427	greg	2.1	if (single_plane_incident) /* resample dist. */
428	greg	2.11	eval_isotropic(NULL);
429	greg	2.1	else
430	greg	2.11	eval_anisotropic(NULL);
431			xml_epilogue(); /* finish XML output & exit */
432	greg	2.1	return(0);
433			userr:
434			fprintf(stderr,
435	greg	2.18	"Usage: %s [-g Nlog2][-t pctcull][-l maxlobes] [bsdf.sir ..] > bsdf.xml\n",
436	greg	2.11	progname);
437			fprintf(stderr,
438			" or: %s -t{3\|4} [-g Nlog2][-t pctcull][{+\|-}for[ward]][{+\|-}b[ackward]][-e expr][-f file] bsdf_func > bsdf.xml\n",
439	greg	2.1	progname);
440			return(1);
441			}