src/cv/bsdf2ttree.c

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