src/cv/bsdf2ttree.c

#ifndef lint
static const char RCSid[] = "$Id: bsdf2ttree.c,v 2.39 2016/10/13 16:59:29 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 "paths.h"
#include "rtio.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          64
#endif
                                /* limit on number of RBF lobes */
static int              lobe_lim = 15000;
                                /* progress bar length */
static int              do_prog = 79;

#define MAXCARG         512     /* wrapBSDF command */
static char             *wrapBSDF[MAXCARG] = {"wrapBSDF", "-U"};
static int              wbsdfac = 2;

/* Add argument to wrapBSDF, allocating space if !isstatic */
static void
add_wbsdf(const char *arg, int isstatic)
{
        if (arg == NULL)
                return;
        if (wbsdfac >= MAXCARG-1) {
                fputs(progname, stderr);
                fputs(": too many command arguments to wrapBSDF\n", stderr);
                exit(1);
        }
        if (!*arg)
                arg = "";
        else if (!isstatic)
                arg = savqstr((char *)arg);

        wrapBSDF[wbsdfac++] = (char *)arg;
}

/* Create Yuv component file and add appropriate arguments */
static char *
create_component_file(int c)
{
        static const char       sname[3][6] = {"CIE-Y", "CIE-u", "CIE-v"};
        static const char       cname[4][4] = {"-rf", "-tf", "-tb", "-rb"};
        char                    *tfname = mktemp(savqstr(TEMPLATE));

        add_wbsdf("-s", 1); add_wbsdf(sname[c], 1);
        add_wbsdf(cname[(input_orient>0)<<1 | (output_orient>0)], 1);
        add_wbsdf(tfname, 1);
        return(tfname);
}

/* 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, *uvfp[2];
        int             assignD = 0;
        char            cmd[128];
        int             ix, ox, oy;
        double          iovec[6];
        float           bsdf, uv[2];

        if (pctcull >= 0) {
                sprintf(cmd, "rttree_reduce -a -h -ff -r 3 -t %f -g %d > %s",
                                pctcull, samp_order, create_component_file(0));
                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
                if (rbf_colorimetry == RBCtristimulus) {
                        double  uvcull = 100. - (100.-pctcull)*.25;
                        sprintf(cmd, "rttree_reduce -a -h -ff -r 3 -t %f -g %d > %s",
                                        uvcull, samp_order, create_component_file(1));
                        uvfp[0] = popen(cmd, "w");
                        sprintf(cmd, "rttree_reduce -a -h -ff -r 3 -t %f -g %d > %s",
                                        uvcull, samp_order, create_component_file(2));
                        uvfp[1] = popen(cmd, "w");
                        if ((uvfp[0] == NULL) | (uvfp[1] == NULL)) {
                                fprintf(stderr, "%s: cannot open pipes to uv output\n",
                                                progname);
                                exit(1);
                        }
                        SET_FILE_BINARY(uvfp[0]); SET_FILE_BINARY(uvfp[1]);
#ifdef getc_unlocked
                        flockfile(uvfp[0]); flockfile(uvfp[1]);
#endif
                }
        } else {
                ofp = fopen(create_component_file(0), "w");
                if (ofp == NULL) {
                        fprintf(stderr, "%s: cannot create Y output file\n",
                                        progname);
                        exit(1);
                }
                fputs("{\n", ofp);
                if (rbf_colorimetry == RBCtristimulus) {
                        uvfp[0] = fopen(create_component_file(1), "w");
                        uvfp[1] = fopen(create_component_file(2), "w");
                        if ((uvfp[0] == NULL) | (uvfp[1] == NULL)) {
                                fprintf(stderr, "%s: cannot create uv output file(s)\n",
                                                progname);
                                exit(1);
                        }
                        fputs("{\n", uvfp[0]);
                        fputs("{\n", uvfp[1]);
                }
        }
        if (funame != NULL)                     /* need to assign Dx, Dy, Dz? */
                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) {
                            SDValue     sdv;
                            eval_rbfcol(&sdv, rbf, iovec+3);
                            bsdf = sdv.cieY;
                            if (rbf_colorimetry == RBCtristimulus) {
                                uv[0] = uv[1] = 1. /
                                    (-2.*sdv.spec.cx + 12.*sdv.spec.cy + 3.);
                                uv[0] *= 4.*sdv.spec.cx;
                                uv[1] *= 9.*sdv.spec.cy;
                            }
                        } 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)
                                putbinary(&bsdf, sizeof(bsdf), 1, ofp);
                        else
                                fprintf(ofp, "\t%.3e\n", bsdf);

                        if (rbf_colorimetry == RBCtristimulus) {
                                if (pctcull >= 0) {
                                        putbinary(&uv[0], sizeof(*uv), 1, uvfp[0]);
                                        putbinary(&uv[1], sizeof(*uv), 1, uvfp[1]);
                                } else {
                                        fprintf(uvfp[0], "\t%.3e\n", uv[0]);
                                        fprintf(uvfp[1], "\t%.3e\n", uv[1]);
                                }
                        }
                        last_bsdf = bsdf;
                    }
                }
                if (rbf != NULL)
                        free(rbf);
                prog_show((ix+1.)*(2./sqres));
        }
        prog_done();
        if (pctcull >= 0) {                     /* finish output */
                if (pclose(ofp)) {
                        fprintf(stderr, "%s: error running rttree_reduce on Y\n",
                                        progname);
                        exit(1);
                }
                if (rbf_colorimetry == RBCtristimulus &&
                                (pclose(uvfp[0]) || pclose(uvfp[1]))) {
                        fprintf(stderr, "%s: error running rttree_reduce on uv\n",
                                        progname);
                        exit(1);
                }
        } else {
                for (ix = sqres*sqres*sqres/2; ix--; )
                        fputs("\t0\n", ofp);
                fputs("}\n", ofp);
                if (fclose(ofp)) {
                        fprintf(stderr, "%s: error writing Y file\n",
                                        progname);
                        exit(1);
                }
                if (rbf_colorimetry == RBCtristimulus) {
                        for (ix = sqres*sqres*sqres/2; ix--; ) {
                                fputs("\t0\n", uvfp[0]);
                                fputs("\t0\n", uvfp[1]);
                        }
                        fputs("}\n", uvfp[0]);
                        fputs("}\n", uvfp[1]);
                        if (fclose(uvfp[0]) || fclose(uvfp[1])) {
                                fprintf(stderr, "%s: error writing uv file(s)\n",
                                                progname);
                                exit(1);
                        }
                }
        }
}

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

        if (pctcull >= 0) {
                const char      *avgopt = (input_orient>0 ^ output_orient>0)
                                                ? "" : " -a";
                sprintf(cmd, "rttree_reduce%s -h -ff -r 4 -t %f -g %d > %s",
                                avgopt, pctcull, samp_order,
                                create_component_file(0));
                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
                if (rbf_colorimetry == RBCtristimulus) {
                        double  uvcull = 100. - (100.-pctcull)*.25;
                        sprintf(cmd, "rttree_reduce%s -h -ff -r 4 -t %f -g %d > %s",
                                        avgopt, uvcull, samp_order,
                                        create_component_file(1));
                        uvfp[0] = popen(cmd, "w");
                        sprintf(cmd, "rttree_reduce%s -h -ff -r 4 -t %f -g %d > %s",
                                        avgopt, uvcull, samp_order,
                                        create_component_file(2));
                        uvfp[1] = popen(cmd, "w");
                        if ((uvfp[0] == NULL) | (uvfp[1] == NULL)) {
                                fprintf(stderr, "%s: cannot open pipes to uv output\n",
                                                progname);
                                exit(1);
                        }
                        SET_FILE_BINARY(uvfp[0]); SET_FILE_BINARY(uvfp[1]);
#ifdef getc_unlocked
                        flockfile(uvfp[0]); flockfile(uvfp[1]);
#endif
                }
        } else {
                ofp = fopen(create_component_file(0), "w");
                if (ofp == NULL) {
                        fprintf(stderr, "%s: cannot create Y output file\n",
                                        progname);
                        exit(1);
                }
                fputs("{\n", ofp);
                if (rbf_colorimetry == RBCtristimulus) {
                        uvfp[0] = fopen(create_component_file(1), "w");
                        uvfp[1] = fopen(create_component_file(2), "w");
                        if ((uvfp[0] == NULL) | (uvfp[1] == NULL)) {
                                fprintf(stderr, "%s: cannot create uv output file(s)\n",
                                                progname);
                                exit(1);
                        }
                        fputs("{\n", uvfp[0]);
                        fputs("{\n", uvfp[1]);
                }
        }
        if (funame != NULL)                     /* need to assign Dx, Dy, Dz? */
                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) {
                            SDValue     sdv;
                            eval_rbfcol(&sdv, rbf, iovec+3);
                            bsdf = sdv.cieY;
                            if (rbf_colorimetry == RBCtristimulus) {
                                uv[0] = uv[1] = 1. /
                                    (-2.*sdv.spec.cx + 12.*sdv.spec.cy + 3.);
                                uv[0] *= 4.*sdv.spec.cx;
                                uv[1] *= 9.*sdv.spec.cy;
                            }
                        } 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)
                                putbinary(&bsdf, sizeof(bsdf), 1, ofp);
                        else
                                fprintf(ofp, "\t%.3e\n", bsdf);

                        if (rbf_colorimetry == RBCtristimulus) {
                                if (pctcull >= 0) {
                                        putbinary(&uv[0], sizeof(*uv), 1, uvfp[0]);
                                        putbinary(&uv[1], sizeof(*uv), 1, uvfp[1]);
                                } else {
                                        fprintf(uvfp[0], "\t%.3e\n", uv[0]);
                                        fprintf(uvfp[1], "\t%.3e\n", uv[1]);
                                }
                        }
                        last_bsdf = bsdf;
                    }
                }
                if (rbf != NULL)
                        free(rbf);
                prog_show((ix*sqres+iy+1.)/(sqres*sqres));
            }
        prog_done();
        if (pctcull >= 0) {                     /* finish output */
                if (pclose(ofp)) {
                        fprintf(stderr, "%s: error running rttree_reduce on Y\n",
                                        progname);
                        exit(1);
                }
                if (rbf_colorimetry == RBCtristimulus &&
                                (pclose(uvfp[0]) || pclose(uvfp[1]))) {
                        fprintf(stderr, "%s: error running rttree_reduce on uv\n",
                                        progname);
                        exit(1);
                }
        } else {
                fputs("}\n", ofp);
                if (fclose(ofp)) {
                        fprintf(stderr, "%s: error writing Y file\n",
                                        progname);
                        exit(1);
                }
                if (rbf_colorimetry == RBCtristimulus) {
                        fputs("}\n", uvfp[0]);
                        fputs("}\n", uvfp[1]);
                        if (fclose(uvfp[0]) || fclose(uvfp[1])) {
                                fprintf(stderr, "%s: error writing uv file(s)\n",
                                                progname);
                                exit(1);
                        }
                }
        }
}

#if defined(_WIN32) || defined(_WIN64)
/* Execute wrapBSDF command (may never return) */
static int
wrap_up(void)
{
        char    cmd[8192];

        if (bsdf_manuf[0]) {
                add_wbsdf("-f", 1);
                strcpy(cmd, "m=");
                strcpy(cmd+2, bsdf_manuf);
                add_wbsdf(cmd, 0);
        }
        if (bsdf_name[0]) {
                add_wbsdf("-f", 1);
                strcpy(cmd, "n=");
                strcpy(cmd+2, bsdf_name);
                add_wbsdf(cmd, 0);
        }
        if (!convert_commandline(cmd, sizeof(cmd), wrapBSDF)) {
                fputs(progname, stderr);
                fputs(": command line too long in wrap_up()\n", stderr);
                return(1);
        }
        return(system(cmd));
}
#else
/* Execute wrapBSDF command (may never return) */
static int
wrap_up(void)
{
        char    buf[256];
        char    *compath = getpath((char *)wrapBSDF[0], getenv("PATH"), X_OK);

        if (compath == NULL) {
                fprintf(stderr, "%s: cannot locate %s\n", progname, wrapBSDF[0]);
                return(1);
        }
        if (bsdf_manuf[0]) {
                add_wbsdf("-f", 1);
                strcpy(buf, "m=");
                strcpy(buf+2, bsdf_manuf);
                add_wbsdf(buf, 0);
        }
        if (bsdf_name[0]) {
                add_wbsdf("-f", 1);
                strcpy(buf, "n=");
                strcpy(buf+2, bsdf_name);
                add_wbsdf(buf, 0);
        }
        execv(compath, wrapBSDF);       /* successful call never returns */
        perror(compath);
        return(1);
}
#endif

/* Read in BSDF and interpolate as tensor tree representation */
int
main(int argc, char *argv[])
{
        static char     tfmt[2][4] = {"t4", "t3"};
        int     dofwd = 0, dobwd = 1;
        char    buf[2048];
        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]) {
                                if (strchr(argv[++i], '=') != NULL) {
                                        add_wbsdf("-f", 1);
                                        add_wbsdf(argv[i], 1);
                                } else
                                        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;
                case 'W':
                        add_wbsdf(argv[i], 1);
                        break;
                case 'u':
                case 'C':
                        add_wbsdf(argv[i], 1);
                        add_wbsdf(argv[++i], 1);
                        break;
                default:
                        goto userr;
                }
        strcpy(buf, "File produced by: ");
        if (convert_commandline(buf+18, sizeof(buf)-18, argv) != NULL) {
                add_wbsdf("-C", 1); add_wbsdf(buf, 0);
        }
        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;
                add_wbsdf("-a", 1);
                add_wbsdf(tfmt[single_plane_incident], 1);
                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]);
                }
                return(wrap_up());
        }
        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);
                        sprintf(pbuf, "Interpolating component '%s'", argv[i]);
                        prog_start(pbuf);
                        if (!nbsdf++) {
                                add_wbsdf("-a", 1);
                                add_wbsdf(tfmt[single_plane_incident], 1);
                        }
                        if (single_plane_incident)
                                eval_isotropic(NULL);
                        else
                                eval_anisotropic(NULL);
                }
                return(wrap_up());
        }
        SET_FILE_BINARY(stdin);                 /* load from stdin */
        if (!load_bsdf_rep(stdin))
                return(1);
        prog_start("Interpolating from standard input");
        add_wbsdf("-a", 1);
        add_wbsdf(tfmt[single_plane_incident], 1);
        if (single_plane_incident)              /* resample dist. */
                eval_isotropic(NULL);
        else
                eval_anisotropic(NULL);

        return(wrap_up());
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.40
Committed:	Fri Feb 17 22:31:49 2017 UTC (7 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.39:	+1 -3 lines
Log Message:	Removed unnecessary calls to c_ccvt()
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.40	static const char RCSid[] = "$Id: bsdf2ttree.c,v 2.39 2016/10/13 16:59:29 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.34	#include "paths.h"
17			#include "rtio.h"
18	greg	2.11	#include "calcomp.h"
19	greg	2.1	#include "bsdfrep.h"
20			/* global argv[0] */
21			char *progname;
22			/* percentage to cull (<0 to turn off) */
23	greg	2.31	static double pctcull = 90.;
24	greg	2.1	/* sampling order */
25	greg	2.31	static int samp_order = 6;
26	greg	2.15	/* super-sampling threshold */
27			const double ssamp_thresh = 0.35;
28			/* number of super-samples */
29	greg	2.28	#ifndef NSSAMP
30	greg	2.38	#define NSSAMP 64
31	greg	2.28	#endif
32	greg	2.18	/* limit on number of RBF lobes */
33			static int lobe_lim = 15000;
34	greg	2.26	/* progress bar length */
35			static int do_prog = 79;
36
37	greg	2.34	#define MAXCARG 512 /* wrapBSDF command */
38			static char *wrapBSDF[MAXCARG] = {"wrapBSDF", "-U"};
39			static int wbsdfac = 2;
40
41	greg	2.39	/* Add argument to wrapBSDF, allocating space if !isstatic */
42	greg	2.34	static void
43			add_wbsdf(const char *arg, int isstatic)
44			{
45			if (arg == NULL)
46			return;
47			if (wbsdfac >= MAXCARG-1) {
48			fputs(progname, stderr);
49			fputs(": too many command arguments to wrapBSDF\n", stderr);
50			exit(1);
51			}
52			if (!*arg)
53			arg = "";
54			else if (!isstatic)
55			arg = savqstr((char *)arg);
56
57			wrapBSDF[wbsdfac++] = (char *)arg;
58			}
59
60			/* Create Yuv component file and add appropriate arguments */
61			static char *
62			create_component_file(int c)
63			{
64			static const char sname[3][6] = {"CIE-Y", "CIE-u", "CIE-v"};
65			static const char cname[4][4] = {"-rf", "-tf", "-tb", "-rb"};
66			char *tfname = mktemp(savqstr(TEMPLATE));
67
68			add_wbsdf("-s", 1); add_wbsdf(sname[c], 1);
69			add_wbsdf(cname[(input_orient>0)<<1 \| (output_orient>0)], 1);
70			add_wbsdf(tfname, 1);
71			return(tfname);
72			}
73	greg	2.26
74			/* Start new progress bar */
75			#define prog_start(s) if (do_prog) fprintf(stderr, "%s: %s...\n", progname, s); else
76
77			/* Draw progress bar of the appropriate length */
78			static void
79			prog_show(double frac)
80			{
81	greg	2.30	static unsigned call_cnt = 0;
82			static char lastc[] = "-\\\|/";
83			char pbar[256];
84			int nchars;
85	greg	2.26
86	greg	2.30	if (do_prog <= 1) return;
87	greg	2.26	if (do_prog > sizeof(pbar)-2)
88			do_prog = sizeof(pbar)-2;
89			if (frac < 0) frac = 0;
90	greg	2.30	else if (frac >= 1) frac = .9999;
91			nchars = do_prog*frac;
92	greg	2.26	pbar[0] = '\r';
93			memset(pbar+1, '*', nchars);
94	greg	2.30	pbar[nchars+1] = lastc[call_cnt++ & 3];
95			memset(pbar+2+nchars, '-', do_prog-nchars-1);
96	greg	2.26	pbar[do_prog+1] = '\0';
97			fputs(pbar, stderr);
98			}
99
100			/* Finish progress bar */
101	greg	2.27	static void
102			prog_done(void)
103			{
104			int n = do_prog;
105
106			if (n <= 1) return;
107			fputc('\r', stderr);
108			while (n--)
109			fputc(' ', stderr);
110			fputc('\r', stderr);
111			}
112	greg	2.1
113	greg	2.15	/* Compute absolute relative difference */
114			static double
115			abs_diff(double v1, double v0)
116			{
117			if ((v0 < 0) \| (v1 < 0))
118			return(.0);
119			v1 = (v1-v0)*2./(v0+v1+.0001);
120			if (v1 < 0)
121			return(-v1);
122			return(v1);
123			}
124
125	greg	2.1	/* Interpolate and output isotropic BSDF data */
126			static void
127	greg	2.11	eval_isotropic(char *funame)
128	greg	2.1	{
129			const int sqres = 1<<samp_order;
130	greg	2.34	FILE ofp, uvfp[2];
131	greg	2.17	int assignD = 0;
132	greg	2.1	char cmd[128];
133			int ix, ox, oy;
134	greg	2.11	double iovec[6];
135	greg	2.34	float bsdf, uv[2];
136	greg	2.15
137	greg	2.11	if (pctcull >= 0) {
138	greg	2.34	sprintf(cmd, "rttree_reduce -a -h -ff -r 3 -t %f -g %d > %s",
139			pctcull, samp_order, create_component_file(0));
140	greg	2.1	ofp = popen(cmd, "w");
141			if (ofp == NULL) {
142			fprintf(stderr, "%s: cannot create pipe to rttree_reduce\n",
143			progname);
144			exit(1);
145			}
146			SET_FILE_BINARY(ofp);
147	greg	2.25	#ifdef getc_unlocked /* avoid lock/unlock overhead */
148			flockfile(ofp);
149			#endif
150	greg	2.34	if (rbf_colorimetry == RBCtristimulus) {
151			double uvcull = 100. - (100.-pctcull)*.25;
152			sprintf(cmd, "rttree_reduce -a -h -ff -r 3 -t %f -g %d > %s",
153			uvcull, samp_order, create_component_file(1));
154			uvfp[0] = popen(cmd, "w");
155			sprintf(cmd, "rttree_reduce -a -h -ff -r 3 -t %f -g %d > %s",
156			uvcull, samp_order, create_component_file(2));
157			uvfp[1] = popen(cmd, "w");
158			if ((uvfp[0] == NULL) \| (uvfp[1] == NULL)) {
159			fprintf(stderr, "%s: cannot open pipes to uv output\n",
160			progname);
161			exit(1);
162			}
163			SET_FILE_BINARY(uvfp[0]); SET_FILE_BINARY(uvfp[1]);
164			#ifdef getc_unlocked
165			flockfile(uvfp[0]); flockfile(uvfp[1]);
166			#endif
167			}
168			} else {
169			ofp = fopen(create_component_file(0), "w");
170			if (ofp == NULL) {
171			fprintf(stderr, "%s: cannot create Y output file\n",
172			progname);
173			exit(1);
174			}
175			fputs("{\n", ofp);
176			if (rbf_colorimetry == RBCtristimulus) {
177			uvfp[0] = fopen(create_component_file(1), "w");
178			uvfp[1] = fopen(create_component_file(2), "w");
179			if ((uvfp[0] == NULL) \| (uvfp[1] == NULL)) {
180			fprintf(stderr, "%s: cannot create uv output file(s)\n",
181			progname);
182			exit(1);
183			}
184			fputs("{\n", uvfp[0]);
185			fputs("{\n", uvfp[1]);
186			}
187			}
188	greg	2.35	if (funame != NULL) /* need to assign Dx, Dy, Dz? */
189	greg	2.17	assignD = (fundefined(funame) < 6);
190	greg	2.1	/* run through directions */
191			for (ix = 0; ix < sqres/2; ix++) {
192	greg	2.11	RBFNODE *rbf = NULL;
193	greg	2.14	iovec[0] = 2.*(ix+.5)/sqres - 1.;
194	greg	2.11	iovec[1] = .0;
195			iovec[2] = input_orient * sqrt(1. - iovec[0]*iovec[0]);
196			if (funame == NULL)
197	greg	2.18	rbf = advect_rbf(iovec, lobe_lim);
198	greg	2.15	for (ox = 0; ox < sqres; ox++) {
199			float last_bsdf = -1;
200	greg	2.1	for (oy = 0; oy < sqres; oy++) {
201	greg	2.11	SDsquare2disk(iovec+3, (ox+.5)/sqres, (oy+.5)/sqres);
202			iovec[5] = output_orient *
203			sqrt(1. - iovec[3]iovec[3] - iovec[4]iovec[4]);
204	greg	2.34	if (funame == NULL) {
205			SDValue sdv;
206			eval_rbfcol(&sdv, rbf, iovec+3);
207			bsdf = sdv.cieY;
208			if (rbf_colorimetry == RBCtristimulus) {
209			uv[0] = uv[1] = 1. /
210			(-2.sdv.spec.cx + 12.sdv.spec.cy + 3.);
211			uv[0] = 4.sdv.spec.cx;
212			uv[1] = 9.sdv.spec.cy;
213			}
214			} else {
215	greg	2.17	if (assignD) {
216			varset("Dx", '=', -iovec[3]);
217			varset("Dy", '=', -iovec[4]);
218			varset("Dz", '=', -iovec[5]);
219			++eclock;
220			}
221	greg	2.15	bsdf = funvalue(funame, 6, iovec);
222	greg	2.28	#if (NSSAMP > 0)
223	greg	2.15	if (abs_diff(bsdf, last_bsdf) > ssamp_thresh) {
224	greg	2.28	int ssi;
225			double ssa[3], ssvec[6], sum = 0;
226			/* super-sample voxel */
227			for (ssi = NSSAMP; ssi--; ) {
228			SDmultiSamp(ssa, 3, (ssi+frandom()) *
229			(1./NSSAMP));
230	greg	2.15	ssvec[0] = 2.*(ix+ssa[0])/sqres - 1.;
231			ssvec[1] = .0;
232			ssvec[2] = input_orient *
233			sqrt(1. - ssvec[0]*ssvec[0]);
234			SDsquare2disk(ssvec+3, (ox+ssa[1])/sqres,
235			(oy+ssa[2])/sqres);
236			ssvec[5] = output_orient *
237			sqrt(1. - ssvec[3]*ssvec[3] -
238			ssvec[4]*ssvec[4]);
239	greg	2.17	if (assignD) {
240	greg	2.28	varset("Dx", '=', -ssvec[3]);
241			varset("Dy", '=', -ssvec[4]);
242			varset("Dz", '=', -ssvec[5]);
243	greg	2.17	++eclock;
244			}
245	greg	2.16	sum += funvalue(funame, 6, ssvec);
246	greg	2.15	}
247	greg	2.28	bsdf = sum/NSSAMP;
248	greg	2.15	}
249	greg	2.28	#endif
250	greg	2.15	}
251	greg	2.1	if (pctcull >= 0)
252	greg	2.37	putbinary(&bsdf, sizeof(bsdf), 1, ofp);
253	greg	2.1	else
254	greg	2.34	fprintf(ofp, "\t%.3e\n", bsdf);
255
256			if (rbf_colorimetry == RBCtristimulus) {
257			if (pctcull >= 0) {
258	greg	2.37	putbinary(&uv[0], sizeof(*uv), 1, uvfp[0]);
259			putbinary(&uv[1], sizeof(*uv), 1, uvfp[1]);
260	greg	2.34	} else {
261			fprintf(uvfp[0], "\t%.3e\n", uv[0]);
262			fprintf(uvfp[1], "\t%.3e\n", uv[1]);
263			}
264			}
265	greg	2.15	last_bsdf = bsdf;
266	greg	2.1	}
267	greg	2.15	}
268	greg	2.3	if (rbf != NULL)
269			free(rbf);
270	greg	2.26	prog_show((ix+1.)*(2./sqres));
271	greg	2.1	}
272	greg	2.35	prog_done();
273	greg	2.1	if (pctcull >= 0) { /* finish output */
274			if (pclose(ofp)) {
275	greg	2.34	fprintf(stderr, "%s: error running rttree_reduce on Y\n",
276			progname);
277			exit(1);
278			}
279			if (rbf_colorimetry == RBCtristimulus &&
280			(pclose(uvfp[0]) \|\| pclose(uvfp[1]))) {
281			fprintf(stderr, "%s: error running rttree_reduce on uv\n",
282			progname);
283	greg	2.1	exit(1);
284			}
285			} else {
286			for (ix = sqressqressqres/2; ix--; )
287	greg	2.34	fputs("\t0\n", ofp);
288			fputs("}\n", ofp);
289			if (fclose(ofp)) {
290			fprintf(stderr, "%s: error writing Y file\n",
291			progname);
292			exit(1);
293			}
294			if (rbf_colorimetry == RBCtristimulus) {
295			for (ix = sqressqressqres/2; ix--; ) {
296			fputs("\t0\n", uvfp[0]);
297			fputs("\t0\n", uvfp[1]);
298			}
299			fputs("}\n", uvfp[0]);
300			fputs("}\n", uvfp[1]);
301			if (fclose(uvfp[0]) \|\| fclose(uvfp[1])) {
302			fprintf(stderr, "%s: error writing uv file(s)\n",
303			progname);
304			exit(1);
305			}
306			}
307	greg	2.1	}
308			}
309
310			/* Interpolate and output anisotropic BSDF data */
311			static void
312	greg	2.11	eval_anisotropic(char *funame)
313	greg	2.1	{
314			const int sqres = 1<<samp_order;
315	greg	2.34	FILE ofp, uvfp[2];
316	greg	2.17	int assignD = 0;
317	greg	2.1	char cmd[128];
318			int ix, iy, ox, oy;
319	greg	2.11	double iovec[6];
320	greg	2.34	float bsdf, uv[2];
321	greg	2.15
322	greg	2.11	if (pctcull >= 0) {
323	greg	2.35	const char *avgopt = (input_orient>0 ^ output_orient>0)
324			? "" : " -a";
325	greg	2.34	sprintf(cmd, "rttree_reduce%s -h -ff -r 4 -t %f -g %d > %s",
326	greg	2.35	avgopt, pctcull, samp_order,
327			create_component_file(0));
328	greg	2.1	ofp = popen(cmd, "w");
329			if (ofp == NULL) {
330			fprintf(stderr, "%s: cannot create pipe to rttree_reduce\n",
331			progname);
332			exit(1);
333			}
334	greg	2.25	SET_FILE_BINARY(ofp);
335			#ifdef getc_unlocked /* avoid lock/unlock overhead */
336			flockfile(ofp);
337			#endif
338	greg	2.34	if (rbf_colorimetry == RBCtristimulus) {
339			double uvcull = 100. - (100.-pctcull)*.25;
340			sprintf(cmd, "rttree_reduce%s -h -ff -r 4 -t %f -g %d > %s",
341	greg	2.35	avgopt, uvcull, samp_order,
342			create_component_file(1));
343	greg	2.34	uvfp[0] = popen(cmd, "w");
344			sprintf(cmd, "rttree_reduce%s -h -ff -r 4 -t %f -g %d > %s",
345	greg	2.35	avgopt, uvcull, samp_order,
346			create_component_file(2));
347	greg	2.34	uvfp[1] = popen(cmd, "w");
348			if ((uvfp[0] == NULL) \| (uvfp[1] == NULL)) {
349			fprintf(stderr, "%s: cannot open pipes to uv output\n",
350			progname);
351			exit(1);
352			}
353			SET_FILE_BINARY(uvfp[0]); SET_FILE_BINARY(uvfp[1]);
354			#ifdef getc_unlocked
355			flockfile(uvfp[0]); flockfile(uvfp[1]);
356			#endif
357			}
358			} else {
359			ofp = fopen(create_component_file(0), "w");
360			if (ofp == NULL) {
361			fprintf(stderr, "%s: cannot create Y output file\n",
362			progname);
363			exit(1);
364			}
365			fputs("{\n", ofp);
366			if (rbf_colorimetry == RBCtristimulus) {
367			uvfp[0] = fopen(create_component_file(1), "w");
368			uvfp[1] = fopen(create_component_file(2), "w");
369			if ((uvfp[0] == NULL) \| (uvfp[1] == NULL)) {
370			fprintf(stderr, "%s: cannot create uv output file(s)\n",
371			progname);
372			exit(1);
373			}
374			fputs("{\n", uvfp[0]);
375			fputs("{\n", uvfp[1]);
376			}
377			}
378	greg	2.35	if (funame != NULL) /* need to assign Dx, Dy, Dz? */
379	greg	2.17	assignD = (fundefined(funame) < 6);
380	greg	2.1	/* run through directions */
381			for (ix = 0; ix < sqres; ix++)
382			for (iy = 0; iy < sqres; iy++) {
383	greg	2.11	RBFNODE rbf = NULL; / Klems reversal */
384	greg	2.15	SDsquare2disk(iovec, 1.-(ix+.5)/sqres, 1.-(iy+.5)/sqres);
385	greg	2.11	iovec[2] = input_orient *
386			sqrt(1. - iovec[0]iovec[0] - iovec[1]iovec[1]);
387			if (funame == NULL)
388	greg	2.18	rbf = advect_rbf(iovec, lobe_lim);
389	greg	2.15	for (ox = 0; ox < sqres; ox++) {
390			float last_bsdf = -1;
391	greg	2.1	for (oy = 0; oy < sqres; oy++) {
392	greg	2.11	SDsquare2disk(iovec+3, (ox+.5)/sqres, (oy+.5)/sqres);
393			iovec[5] = output_orient *
394			sqrt(1. - iovec[3]iovec[3] - iovec[4]iovec[4]);
395	greg	2.34	if (funame == NULL) {
396			SDValue sdv;
397			eval_rbfcol(&sdv, rbf, iovec+3);
398			bsdf = sdv.cieY;
399			if (rbf_colorimetry == RBCtristimulus) {
400			uv[0] = uv[1] = 1. /
401			(-2.sdv.spec.cx + 12.sdv.spec.cy + 3.);
402			uv[0] = 4.sdv.spec.cx;
403			uv[1] = 9.sdv.spec.cy;
404			}
405			} else {
406	greg	2.17	if (assignD) {
407			varset("Dx", '=', -iovec[3]);
408			varset("Dy", '=', -iovec[4]);
409			varset("Dz", '=', -iovec[5]);
410			++eclock;
411			}
412	greg	2.15	bsdf = funvalue(funame, 6, iovec);
413	greg	2.28	#if (NSSAMP > 0)
414	greg	2.15	if (abs_diff(bsdf, last_bsdf) > ssamp_thresh) {
415	greg	2.28	int ssi;
416			double ssa[4], ssvec[6], sum = 0;
417			/* super-sample voxel */
418			for (ssi = NSSAMP; ssi--; ) {
419			SDmultiSamp(ssa, 4, (ssi+frandom()) *
420			(1./NSSAMP));
421	greg	2.15	SDsquare2disk(ssvec, 1.-(ix+ssa[0])/sqres,
422			1.-(iy+ssa[1])/sqres);
423	greg	2.28	ssvec[2] = input_orient *
424	greg	2.15	sqrt(1. - ssvec[0]*ssvec[0] -
425			ssvec[1]*ssvec[1]);
426			SDsquare2disk(ssvec+3, (ox+ssa[2])/sqres,
427			(oy+ssa[3])/sqres);
428			ssvec[5] = output_orient *
429			sqrt(1. - ssvec[3]*ssvec[3] -
430			ssvec[4]*ssvec[4]);
431	greg	2.17	if (assignD) {
432	greg	2.28	varset("Dx", '=', -ssvec[3]);
433			varset("Dy", '=', -ssvec[4]);
434			varset("Dz", '=', -ssvec[5]);
435	greg	2.17	++eclock;
436			}
437	greg	2.16	sum += funvalue(funame, 6, ssvec);
438	greg	2.15	}
439	greg	2.28	bsdf = sum/NSSAMP;
440	greg	2.15	}
441	greg	2.28	#endif
442	greg	2.15	}
443	greg	2.1	if (pctcull >= 0)
444	greg	2.37	putbinary(&bsdf, sizeof(bsdf), 1, ofp);
445	greg	2.1	else
446	greg	2.34	fprintf(ofp, "\t%.3e\n", bsdf);
447
448			if (rbf_colorimetry == RBCtristimulus) {
449			if (pctcull >= 0) {
450	greg	2.37	putbinary(&uv[0], sizeof(*uv), 1, uvfp[0]);
451			putbinary(&uv[1], sizeof(*uv), 1, uvfp[1]);
452	greg	2.34	} else {
453			fprintf(uvfp[0], "\t%.3e\n", uv[0]);
454			fprintf(uvfp[1], "\t%.3e\n", uv[1]);
455			}
456			}
457	greg	2.15	last_bsdf = bsdf;
458	greg	2.1	}
459	greg	2.15	}
460	greg	2.3	if (rbf != NULL)
461			free(rbf);
462	greg	2.26	prog_show((ixsqres+iy+1.)/(sqressqres));
463	greg	2.1	}
464	greg	2.35	prog_done();
465	greg	2.1	if (pctcull >= 0) { /* finish output */
466			if (pclose(ofp)) {
467	greg	2.34	fprintf(stderr, "%s: error running rttree_reduce on Y\n",
468			progname);
469			exit(1);
470			}
471			if (rbf_colorimetry == RBCtristimulus &&
472			(pclose(uvfp[0]) \|\| pclose(uvfp[1]))) {
473			fprintf(stderr, "%s: error running rttree_reduce on uv\n",
474			progname);
475	greg	2.1	exit(1);
476			}
477	greg	2.34	} else {
478			fputs("}\n", ofp);
479			if (fclose(ofp)) {
480			fprintf(stderr, "%s: error writing Y file\n",
481			progname);
482			exit(1);
483			}
484			if (rbf_colorimetry == RBCtristimulus) {
485			fputs("}\n", uvfp[0]);
486			fputs("}\n", uvfp[1]);
487			if (fclose(uvfp[0]) \|\| fclose(uvfp[1])) {
488			fprintf(stderr, "%s: error writing uv file(s)\n",
489			progname);
490			exit(1);
491			}
492			}
493			}
494	greg	2.5	}
495
496	schorsch	2.36	#if defined(_WIN32) \|\| defined(_WIN64)
497	greg	2.34	/* Execute wrapBSDF command (may never return) */
498			static int
499			wrap_up(void)
500			{
501			char cmd[8192];
502
503			if (bsdf_manuf[0]) {
504			add_wbsdf("-f", 1);
505			strcpy(cmd, "m=");
506			strcpy(cmd+2, bsdf_manuf);
507			add_wbsdf(cmd, 0);
508			}
509			if (bsdf_name[0]) {
510			add_wbsdf("-f", 1);
511			strcpy(cmd, "n=");
512			strcpy(cmd+2, bsdf_name);
513			add_wbsdf(cmd, 0);
514			}
515			if (!convert_commandline(cmd, sizeof(cmd), wrapBSDF)) {
516			fputs(progname, stderr);
517			fputs(": command line too long in wrap_up()\n", stderr);
518			return(1);
519			}
520			return(system(cmd));
521			}
522			#else
523			/* Execute wrapBSDF command (may never return) */
524			static int
525			wrap_up(void)
526			{
527			char buf[256];
528			char compath = getpath((char )wrapBSDF[0], getenv("PATH"), X_OK);
529
530			if (compath == NULL) {
531			fprintf(stderr, "%s: cannot locate %s\n", progname, wrapBSDF[0]);
532			return(1);
533			}
534			if (bsdf_manuf[0]) {
535			add_wbsdf("-f", 1);
536			strcpy(buf, "m=");
537			strcpy(buf+2, bsdf_manuf);
538			add_wbsdf(buf, 0);
539			}
540			if (bsdf_name[0]) {
541			add_wbsdf("-f", 1);
542			strcpy(buf, "n=");
543			strcpy(buf+2, bsdf_name);
544			add_wbsdf(buf, 0);
545			}
546			execv(compath, wrapBSDF); /* successful call never returns */
547			perror(compath);
548			return(1);
549			}
550			#endif
551
552	greg	2.1	/* Read in BSDF and interpolate as tensor tree representation */
553			int
554			main(int argc, char *argv[])
555			{
556	greg	2.34	static char tfmt[2][4] = {"t4", "t3"};
557	greg	2.11	int dofwd = 0, dobwd = 1;
558	greg	2.34	char buf[2048];
559	greg	2.11	int i, na;
560	greg	2.1
561	greg	2.5	progname = argv[0];
562	greg	2.11	esupport \|= E_VARIABLE\|E_FUNCTION\|E_RCONST;
563			esupport &= ~(E_INCHAN\|E_OUTCHAN);
564			scompile("PI:3.14159265358979323846", NULL, 0);
565			biggerlib();
566			for (i = 1; i < argc-1 && (argv[i][0] == '-') \| (argv[i][0] == '+'); i++)
567			switch (argv[i][1]) { /* get options */
568			case 'e':
569			scompile(argv[++i], NULL, 0);
570			break;
571			case 'f':
572	greg	2.34	if (!argv[i][2]) {
573			if (strchr(argv[++i], '=') != NULL) {
574			add_wbsdf("-f", 1);
575			add_wbsdf(argv[i], 1);
576			} else
577			fcompile(argv[i]);
578			} else
579	greg	2.11	dofwd = (argv[i][0] == '+');
580			break;
581			case 'b':
582			dobwd = (argv[i][0] == '+');
583			break;
584	greg	2.1	case 't':
585	greg	2.11	switch (argv[i][2]) {
586			case '3':
587	greg	2.13	single_plane_incident = 1;
588	greg	2.11	break;
589			case '4':
590	greg	2.13	single_plane_incident = 0;
591	greg	2.11	break;
592			case '\0':
593			pctcull = atof(argv[++i]);
594			break;
595			default:
596			goto userr;
597			}
598	greg	2.1	break;
599			case 'g':
600	greg	2.5	samp_order = atoi(argv[++i]);
601	greg	2.1	break;
602	greg	2.18	case 'l':
603			lobe_lim = atoi(argv[++i]);
604			break;
605	greg	2.26	case 'p':
606			do_prog = atoi(argv[i]+2);
607			break;
608	greg	2.34	case 'W':
609			add_wbsdf(argv[i], 1);
610			break;
611			case 'u':
612			case 'C':
613			add_wbsdf(argv[i], 1);
614			add_wbsdf(argv[++i], 1);
615			break;
616	greg	2.1	default:
617			goto userr;
618			}
619	greg	2.34	strcpy(buf, "File produced by: ");
620			if (convert_commandline(buf+18, sizeof(buf)-18, argv) != NULL) {
621			add_wbsdf("-C", 1); add_wbsdf(buf, 0);
622			}
623	greg	2.11	if (single_plane_incident >= 0) { /* function-based BSDF? */
624			void (evf)(char s) = single_plane_incident ?
625	greg	2.34	eval_isotropic : eval_anisotropic;
626	greg	2.17	if (i != argc-1 \|\| fundefined(argv[i]) < 3) {
627	greg	2.12	fprintf(stderr,
628			"%s: need single function with 6 arguments: bsdf(ix,iy,iz,ox,oy,oz)\n",
629			progname);
630	greg	2.24	fprintf(stderr, "\tor 3 arguments using Dx,Dy,Dz: bsdf(ix,iy,iz)\n");
631	greg	2.11	goto userr;
632	greg	2.12	}
633	greg	2.17	++eclock;
634	greg	2.34	add_wbsdf("-a", 1);
635			add_wbsdf(tfmt[single_plane_incident], 1);
636	greg	2.11	if (dofwd) {
637			input_orient = -1;
638			output_orient = -1;
639	greg	2.26	prog_start("Evaluating outside reflectance");
640			(*evf)(argv[i]);
641	greg	2.11	output_orient = 1;
642	greg	2.26	prog_start("Evaluating outside->inside transmission");
643			(*evf)(argv[i]);
644	greg	2.11	}
645			if (dobwd) {
646			input_orient = 1;
647			output_orient = 1;
648	greg	2.26	prog_start("Evaluating inside reflectance");
649			(*evf)(argv[i]);
650	greg	2.11	output_orient = -1;
651	greg	2.26	prog_start("Evaluating inside->outside transmission");
652			(*evf)(argv[i]);
653	greg	2.11	}
654	greg	2.34	return(wrap_up());
655	greg	2.11	}
656			if (i < argc) { /* open input files if given */
657	greg	2.12	int nbsdf = 0;
658	greg	2.11	for ( ; i < argc; i++) { /* interpolate each component */
659	greg	2.26	char pbuf[256];
660	greg	2.11	FILE *fpin = fopen(argv[i], "rb");
661			if (fpin == NULL) {
662			fprintf(stderr, "%s: cannot open BSDF interpolant '%s'\n",
663			progname, argv[i]);
664			return(1);
665			}
666			if (!load_bsdf_rep(fpin))
667			return(1);
668			fclose(fpin);
669	greg	2.26	sprintf(pbuf, "Interpolating component '%s'", argv[i]);
670			prog_start(pbuf);
671	greg	2.34	if (!nbsdf++) {
672			add_wbsdf("-a", 1);
673			add_wbsdf(tfmt[single_plane_incident], 1);
674			}
675	greg	2.11	if (single_plane_incident)
676			eval_isotropic(NULL);
677			else
678			eval_anisotropic(NULL);
679			}
680	greg	2.34	return(wrap_up());
681	greg	2.11	}
682			SET_FILE_BINARY(stdin); /* load from stdin */
683			if (!load_bsdf_rep(stdin))
684	greg	2.1	return(1);
685	greg	2.26	prog_start("Interpolating from standard input");
686	greg	2.34	add_wbsdf("-a", 1);
687			add_wbsdf(tfmt[single_plane_incident], 1);
688	greg	2.1	if (single_plane_incident) /* resample dist. */
689	greg	2.11	eval_isotropic(NULL);
690	greg	2.1	else
691	greg	2.11	eval_anisotropic(NULL);
692	greg	2.34
693			return(wrap_up());
694	greg	2.1	userr:
695			fprintf(stderr,
696	greg	2.18	"Usage: %s [-g Nlog2][-t pctcull][-l maxlobes] [bsdf.sir ..] > bsdf.xml\n",
697	greg	2.11	progname);
698			fprintf(stderr,
699			" or: %s -t{3\|4} [-g Nlog2][-t pctcull][{+\|-}for[ward]][{+\|-}b[ackward]][-e expr][-f file] bsdf_func > bsdf.xml\n",
700	greg	2.1	progname);
701			return(1);
702			}