src/cv/bsdf2ttree.c

#ifndef lint
static const char RCSid[] = "$Id: bsdf2ttree.c,v 2.36 2016/03/06 01:13:17 schorsch 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          100
#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) {
                                c_ccvt(&sdv.spec, C_CSXY);
                                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) {
                                c_ccvt(&sdv.spec, C_CSXY);
                                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.37
Committed:	Thu Aug 18 00:52:48 2016 UTC (7 years, 8 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.36:	+7 -7 lines
Log Message:	Switched over to more efficient fread/fwrite replacements getbinary/putbinary
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.37	static const char RCSid[] = "$Id: bsdf2ttree.c,v 2.36 2016/03/06 01:13:17 schorsch 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			#define NSSAMP 100
31			#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			/* Add argument to wrapBSDF, allocating space if isstatic */
42			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			c_ccvt(&sdv.spec, C_CSXY);
210			uv[0] = uv[1] = 1. /
211			(-2.sdv.spec.cx + 12.sdv.spec.cy + 3.);
212			uv[0] = 4.sdv.spec.cx;
213			uv[1] = 9.sdv.spec.cy;
214			}
215			} else {
216	greg	2.17	if (assignD) {
217			varset("Dx", '=', -iovec[3]);
218			varset("Dy", '=', -iovec[4]);
219			varset("Dz", '=', -iovec[5]);
220			++eclock;
221			}
222	greg	2.15	bsdf = funvalue(funame, 6, iovec);
223	greg	2.28	#if (NSSAMP > 0)
224	greg	2.15	if (abs_diff(bsdf, last_bsdf) > ssamp_thresh) {
225	greg	2.28	int ssi;
226			double ssa[3], ssvec[6], sum = 0;
227			/* super-sample voxel */
228			for (ssi = NSSAMP; ssi--; ) {
229			SDmultiSamp(ssa, 3, (ssi+frandom()) *
230			(1./NSSAMP));
231	greg	2.15	ssvec[0] = 2.*(ix+ssa[0])/sqres - 1.;
232			ssvec[1] = .0;
233			ssvec[2] = input_orient *
234			sqrt(1. - ssvec[0]*ssvec[0]);
235			SDsquare2disk(ssvec+3, (ox+ssa[1])/sqres,
236			(oy+ssa[2])/sqres);
237			ssvec[5] = output_orient *
238			sqrt(1. - ssvec[3]*ssvec[3] -
239			ssvec[4]*ssvec[4]);
240	greg	2.17	if (assignD) {
241	greg	2.28	varset("Dx", '=', -ssvec[3]);
242			varset("Dy", '=', -ssvec[4]);
243			varset("Dz", '=', -ssvec[5]);
244	greg	2.17	++eclock;
245			}
246	greg	2.16	sum += funvalue(funame, 6, ssvec);
247	greg	2.15	}
248	greg	2.28	bsdf = sum/NSSAMP;
249	greg	2.15	}
250	greg	2.28	#endif
251	greg	2.15	}
252	greg	2.1	if (pctcull >= 0)
253	greg	2.37	putbinary(&bsdf, sizeof(bsdf), 1, ofp);
254	greg	2.1	else
255	greg	2.34	fprintf(ofp, "\t%.3e\n", bsdf);
256
257			if (rbf_colorimetry == RBCtristimulus) {
258			if (pctcull >= 0) {
259	greg	2.37	putbinary(&uv[0], sizeof(*uv), 1, uvfp[0]);
260			putbinary(&uv[1], sizeof(*uv), 1, uvfp[1]);
261	greg	2.34	} else {
262			fprintf(uvfp[0], "\t%.3e\n", uv[0]);
263			fprintf(uvfp[1], "\t%.3e\n", uv[1]);
264			}
265			}
266	greg	2.15	last_bsdf = bsdf;
267	greg	2.1	}
268	greg	2.15	}
269	greg	2.3	if (rbf != NULL)
270			free(rbf);
271	greg	2.26	prog_show((ix+1.)*(2./sqres));
272	greg	2.1	}
273	greg	2.35	prog_done();
274	greg	2.1	if (pctcull >= 0) { /* finish output */
275			if (pclose(ofp)) {
276	greg	2.34	fprintf(stderr, "%s: error running rttree_reduce on Y\n",
277			progname);
278			exit(1);
279			}
280			if (rbf_colorimetry == RBCtristimulus &&
281			(pclose(uvfp[0]) \|\| pclose(uvfp[1]))) {
282			fprintf(stderr, "%s: error running rttree_reduce on uv\n",
283			progname);
284	greg	2.1	exit(1);
285			}
286			} else {
287			for (ix = sqressqressqres/2; ix--; )
288	greg	2.34	fputs("\t0\n", ofp);
289			fputs("}\n", ofp);
290			if (fclose(ofp)) {
291			fprintf(stderr, "%s: error writing Y file\n",
292			progname);
293			exit(1);
294			}
295			if (rbf_colorimetry == RBCtristimulus) {
296			for (ix = sqressqressqres/2; ix--; ) {
297			fputs("\t0\n", uvfp[0]);
298			fputs("\t0\n", uvfp[1]);
299			}
300			fputs("}\n", uvfp[0]);
301			fputs("}\n", uvfp[1]);
302			if (fclose(uvfp[0]) \|\| fclose(uvfp[1])) {
303			fprintf(stderr, "%s: error writing uv file(s)\n",
304			progname);
305			exit(1);
306			}
307			}
308	greg	2.1	}
309			}
310
311			/* Interpolate and output anisotropic BSDF data */
312			static void
313	greg	2.11	eval_anisotropic(char *funame)
314	greg	2.1	{
315			const int sqres = 1<<samp_order;
316	greg	2.34	FILE ofp, uvfp[2];
317	greg	2.17	int assignD = 0;
318	greg	2.1	char cmd[128];
319			int ix, iy, ox, oy;
320	greg	2.11	double iovec[6];
321	greg	2.34	float bsdf, uv[2];
322	greg	2.15
323	greg	2.11	if (pctcull >= 0) {
324	greg	2.35	const char *avgopt = (input_orient>0 ^ output_orient>0)
325			? "" : " -a";
326	greg	2.34	sprintf(cmd, "rttree_reduce%s -h -ff -r 4 -t %f -g %d > %s",
327	greg	2.35	avgopt, pctcull, samp_order,
328			create_component_file(0));
329	greg	2.1	ofp = popen(cmd, "w");
330			if (ofp == NULL) {
331			fprintf(stderr, "%s: cannot create pipe to rttree_reduce\n",
332			progname);
333			exit(1);
334			}
335	greg	2.25	SET_FILE_BINARY(ofp);
336			#ifdef getc_unlocked /* avoid lock/unlock overhead */
337			flockfile(ofp);
338			#endif
339	greg	2.34	if (rbf_colorimetry == RBCtristimulus) {
340			double uvcull = 100. - (100.-pctcull)*.25;
341			sprintf(cmd, "rttree_reduce%s -h -ff -r 4 -t %f -g %d > %s",
342	greg	2.35	avgopt, uvcull, samp_order,
343			create_component_file(1));
344	greg	2.34	uvfp[0] = popen(cmd, "w");
345			sprintf(cmd, "rttree_reduce%s -h -ff -r 4 -t %f -g %d > %s",
346	greg	2.35	avgopt, uvcull, samp_order,
347			create_component_file(2));
348	greg	2.34	uvfp[1] = popen(cmd, "w");
349			if ((uvfp[0] == NULL) \| (uvfp[1] == NULL)) {
350			fprintf(stderr, "%s: cannot open pipes to uv output\n",
351			progname);
352			exit(1);
353			}
354			SET_FILE_BINARY(uvfp[0]); SET_FILE_BINARY(uvfp[1]);
355			#ifdef getc_unlocked
356			flockfile(uvfp[0]); flockfile(uvfp[1]);
357			#endif
358			}
359			} else {
360			ofp = fopen(create_component_file(0), "w");
361			if (ofp == NULL) {
362			fprintf(stderr, "%s: cannot create Y output file\n",
363			progname);
364			exit(1);
365			}
366			fputs("{\n", ofp);
367			if (rbf_colorimetry == RBCtristimulus) {
368			uvfp[0] = fopen(create_component_file(1), "w");
369			uvfp[1] = fopen(create_component_file(2), "w");
370			if ((uvfp[0] == NULL) \| (uvfp[1] == NULL)) {
371			fprintf(stderr, "%s: cannot create uv output file(s)\n",
372			progname);
373			exit(1);
374			}
375			fputs("{\n", uvfp[0]);
376			fputs("{\n", uvfp[1]);
377			}
378			}
379	greg	2.35	if (funame != NULL) /* need to assign Dx, Dy, Dz? */
380	greg	2.17	assignD = (fundefined(funame) < 6);
381	greg	2.1	/* run through directions */
382			for (ix = 0; ix < sqres; ix++)
383			for (iy = 0; iy < sqres; iy++) {
384	greg	2.11	RBFNODE rbf = NULL; / Klems reversal */
385	greg	2.15	SDsquare2disk(iovec, 1.-(ix+.5)/sqres, 1.-(iy+.5)/sqres);
386	greg	2.11	iovec[2] = input_orient *
387			sqrt(1. - iovec[0]iovec[0] - iovec[1]iovec[1]);
388			if (funame == NULL)
389	greg	2.18	rbf = advect_rbf(iovec, lobe_lim);
390	greg	2.15	for (ox = 0; ox < sqres; ox++) {
391			float last_bsdf = -1;
392	greg	2.1	for (oy = 0; oy < sqres; oy++) {
393	greg	2.11	SDsquare2disk(iovec+3, (ox+.5)/sqres, (oy+.5)/sqres);
394			iovec[5] = output_orient *
395			sqrt(1. - iovec[3]iovec[3] - iovec[4]iovec[4]);
396	greg	2.34	if (funame == NULL) {
397			SDValue sdv;
398			eval_rbfcol(&sdv, rbf, iovec+3);
399			bsdf = sdv.cieY;
400			if (rbf_colorimetry == RBCtristimulus) {
401			c_ccvt(&sdv.spec, C_CSXY);
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			for (i = 1; i < argc-1 && (argv[i][0] == '-') \| (argv[i][0] == '+'); i++)
569			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			case 'b':
584			dobwd = (argv[i][0] == '+');
585			break;
586	greg	2.1	case 't':
587	greg	2.11	switch (argv[i][2]) {
588			case '3':
589	greg	2.13	single_plane_incident = 1;
590	greg	2.11	break;
591			case '4':
592	greg	2.13	single_plane_incident = 0;
593	greg	2.11	break;
594			case '\0':
595			pctcull = atof(argv[++i]);
596			break;
597			default:
598			goto userr;
599			}
600	greg	2.1	break;
601			case 'g':
602	greg	2.5	samp_order = atoi(argv[++i]);
603	greg	2.1	break;
604	greg	2.18	case 'l':
605			lobe_lim = atoi(argv[++i]);
606			break;
607	greg	2.26	case 'p':
608			do_prog = atoi(argv[i]+2);
609			break;
610	greg	2.34	case 'W':
611			add_wbsdf(argv[i], 1);
612			break;
613			case 'u':
614			case 'C':
615			add_wbsdf(argv[i], 1);
616			add_wbsdf(argv[++i], 1);
617			break;
618	greg	2.1	default:
619			goto userr;
620			}
621	greg	2.34	strcpy(buf, "File produced by: ");
622			if (convert_commandline(buf+18, sizeof(buf)-18, argv) != NULL) {
623			add_wbsdf("-C", 1); add_wbsdf(buf, 0);
624			}
625	greg	2.11	if (single_plane_incident >= 0) { /* function-based BSDF? */
626			void (evf)(char s) = single_plane_incident ?
627	greg	2.34	eval_isotropic : eval_anisotropic;
628	greg	2.17	if (i != argc-1 \|\| fundefined(argv[i]) < 3) {
629	greg	2.12	fprintf(stderr,
630			"%s: need single function with 6 arguments: bsdf(ix,iy,iz,ox,oy,oz)\n",
631			progname);
632	greg	2.24	fprintf(stderr, "\tor 3 arguments using Dx,Dy,Dz: bsdf(ix,iy,iz)\n");
633	greg	2.11	goto userr;
634	greg	2.12	}
635	greg	2.17	++eclock;
636	greg	2.34	add_wbsdf("-a", 1);
637			add_wbsdf(tfmt[single_plane_incident], 1);
638	greg	2.11	if (dofwd) {
639			input_orient = -1;
640			output_orient = -1;
641	greg	2.26	prog_start("Evaluating outside reflectance");
642			(*evf)(argv[i]);
643	greg	2.11	output_orient = 1;
644	greg	2.26	prog_start("Evaluating outside->inside transmission");
645			(*evf)(argv[i]);
646	greg	2.11	}
647			if (dobwd) {
648			input_orient = 1;
649			output_orient = 1;
650	greg	2.26	prog_start("Evaluating inside reflectance");
651			(*evf)(argv[i]);
652	greg	2.11	output_orient = -1;
653	greg	2.26	prog_start("Evaluating inside->outside transmission");
654			(*evf)(argv[i]);
655	greg	2.11	}
656	greg	2.34	return(wrap_up());
657	greg	2.11	}
658			if (i < argc) { /* open input files if given */
659	greg	2.12	int nbsdf = 0;
660	greg	2.11	for ( ; i < argc; i++) { /* interpolate each component */
661	greg	2.26	char pbuf[256];
662	greg	2.11	FILE *fpin = fopen(argv[i], "rb");
663			if (fpin == NULL) {
664			fprintf(stderr, "%s: cannot open BSDF interpolant '%s'\n",
665			progname, argv[i]);
666			return(1);
667			}
668			if (!load_bsdf_rep(fpin))
669			return(1);
670			fclose(fpin);
671	greg	2.26	sprintf(pbuf, "Interpolating component '%s'", argv[i]);
672			prog_start(pbuf);
673	greg	2.34	if (!nbsdf++) {
674			add_wbsdf("-a", 1);
675			add_wbsdf(tfmt[single_plane_incident], 1);
676			}
677	greg	2.11	if (single_plane_incident)
678			eval_isotropic(NULL);
679			else
680			eval_anisotropic(NULL);
681			}
682	greg	2.34	return(wrap_up());
683	greg	2.11	}
684			SET_FILE_BINARY(stdin); /* load from stdin */
685			if (!load_bsdf_rep(stdin))
686	greg	2.1	return(1);
687	greg	2.26	prog_start("Interpolating from standard input");
688	greg	2.34	add_wbsdf("-a", 1);
689			add_wbsdf(tfmt[single_plane_incident], 1);
690	greg	2.1	if (single_plane_incident) /* resample dist. */
691	greg	2.11	eval_isotropic(NULL);
692	greg	2.1	else
693	greg	2.11	eval_anisotropic(NULL);
694	greg	2.34
695			return(wrap_up());
696	greg	2.1	userr:
697			fprintf(stderr,
698	greg	2.18	"Usage: %s [-g Nlog2][-t pctcull][-l maxlobes] [bsdf.sir ..] > bsdf.xml\n",
699	greg	2.11	progname);
700			fprintf(stderr,
701			" or: %s -t{3\|4} [-g Nlog2][-t pctcull][{+\|-}for[ward]][{+\|-}b[ackward]][-e expr][-f file] bsdf_func > bsdf.xml\n",
702	greg	2.1	progname);
703			return(1);
704			}