| 11 |  | #include <stdio.h> | 
| 12 |  | #include <stdlib.h> | 
| 13 |  | #include <math.h> | 
| 14 | + | #include "random.h" | 
| 15 |  | #include "platform.h" | 
| 16 | + | #include "paths.h" | 
| 17 | + | #include "rtio.h" | 
| 18 | + | #include "calcomp.h" | 
| 19 |  | #include "bsdfrep.h" | 
| 20 |  | /* global argv[0] */ | 
| 21 |  | char                    *progname; | 
| 22 |  | /* percentage to cull (<0 to turn off) */ | 
| 23 | < | int                     pctcull = 90; | 
| 23 | > | static double           pctcull = 90.; | 
| 24 |  | /* sampling order */ | 
| 25 | < | int                     samp_order = 6; | 
| 25 | > | static int              samp_order = 6; | 
| 26 | > | /* super-sampling threshold */ | 
| 27 | > | const double            ssamp_thresh = 0.35; | 
| 28 | > | /* number of super-samples */ | 
| 29 | > | #ifndef NSSAMP | 
| 30 | > | #define NSSAMP          100 | 
| 31 | > | #endif | 
| 32 | > | /* limit on number of RBF lobes */ | 
| 33 | > | static int              lobe_lim = 15000; | 
| 34 | > | /* progress bar length */ | 
| 35 | > | static int              do_prog = 79; | 
| 36 |  |  | 
| 37 | + | #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 | + |  | 
| 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 | + | static unsigned call_cnt = 0; | 
| 82 | + | static char     lastc[] = "-\\|/"; | 
| 83 | + | char            pbar[256]; | 
| 84 | + | int             nchars; | 
| 85 | + |  | 
| 86 | + | if (do_prog <= 1) return; | 
| 87 | + | if (do_prog > sizeof(pbar)-2) | 
| 88 | + | do_prog = sizeof(pbar)-2; | 
| 89 | + | if (frac < 0) frac = 0; | 
| 90 | + | else if (frac >= 1) frac = .9999; | 
| 91 | + | nchars = do_prog*frac; | 
| 92 | + | pbar[0] = '\r'; | 
| 93 | + | memset(pbar+1, '*', nchars); | 
| 94 | + | pbar[nchars+1] = lastc[call_cnt++ & 3]; | 
| 95 | + | memset(pbar+2+nchars, '-', do_prog-nchars-1); | 
| 96 | + | pbar[do_prog+1] = '\0'; | 
| 97 | + | fputs(pbar, stderr); | 
| 98 | + | } | 
| 99 | + |  | 
| 100 | + | /* Finish progress bar */ | 
| 101 | + | 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 | + |  | 
| 113 | + | /* 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 |  | /* Interpolate and output isotropic BSDF data */ | 
| 126 |  | static void | 
| 127 | < | interp_isotropic() | 
| 127 | > | eval_isotropic(char *funame) | 
| 128 |  | { | 
| 129 |  | const int       sqres = 1<<samp_order; | 
| 130 | < | FILE            *ofp = NULL; | 
| 130 | > | FILE            *ofp, *uvfp[2]; | 
| 131 | > | int             assignD = 0; | 
| 132 |  | char            cmd[128]; | 
| 133 |  | int             ix, ox, oy; | 
| 134 | < | FVECT           ivec, ovec; | 
| 135 | < | double          bsdf; | 
| 136 | < | #if DEBUG | 
| 137 | < | fprintf(stderr, "Writing isotropic order %d ", samp_order); | 
| 138 | < | if (pctcull >= 0) fprintf(stderr, "data with %d%% culling\n", pctcull); | 
| 139 | < | else fputs("raw data\n", stderr); | 
| 37 | < | #endif | 
| 38 | < | if (pctcull >= 0) {                     /* begin output */ | 
| 39 | < | sprintf(cmd, "rttree_reduce -h -a -fd -r 3 -t %d -g %d", | 
| 40 | < | pctcull, samp_order); | 
| 41 | < | fflush(stdout); | 
| 134 | > | double          iovec[6]; | 
| 135 | > | float           bsdf, uv[2]; | 
| 136 | > |  | 
| 137 | > | if (pctcull >= 0) { | 
| 138 | > | sprintf(cmd, "rttree_reduce -a -h -ff -r 3 -t %f -g %d > %s", | 
| 139 | > | pctcull, samp_order, create_component_file(0)); | 
| 140 |  | ofp = popen(cmd, "w"); | 
| 141 |  | if (ofp == NULL) { | 
| 142 |  | fprintf(stderr, "%s: cannot create pipe to rttree_reduce\n", | 
| 144 |  | exit(1); | 
| 145 |  | } | 
| 146 |  | SET_FILE_BINARY(ofp); | 
| 147 | < | } else | 
| 148 | < | fputs("{\n", stdout); | 
| 147 | > | #ifdef getc_unlocked                            /* avoid lock/unlock overhead */ | 
| 148 | > | flockfile(ofp); | 
| 149 | > | #endif | 
| 150 | > | 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 | > | if (funame != NULL)                     /* need to assign Dx, Dy, Dz? */ | 
| 189 | > | assignD = (fundefined(funame) < 6); | 
| 190 |  | /* run through directions */ | 
| 191 |  | for (ix = 0; ix < sqres/2; ix++) { | 
| 192 | < | RBFNODE *rbf; | 
| 193 | < | SDsquare2disk(ivec, (ix+.5)/sqres, .5); | 
| 194 | < | ivec[2] = input_orient * | 
| 195 | < | sqrt(1. - ivec[0]*ivec[0] - ivec[1]*ivec[1]); | 
| 196 | < | rbf = advect_rbf(ivec); | 
| 197 | < | for (ox = 0; ox < sqres; ox++) | 
| 192 | > | RBFNODE *rbf = NULL; | 
| 193 | > | iovec[0] = 2.*(ix+.5)/sqres - 1.; | 
| 194 | > | iovec[1] = .0; | 
| 195 | > | iovec[2] = input_orient * sqrt(1. - iovec[0]*iovec[0]); | 
| 196 | > | if (funame == NULL) | 
| 197 | > | rbf = advect_rbf(iovec, lobe_lim); | 
| 198 | > | for (ox = 0; ox < sqres; ox++) { | 
| 199 | > | float       last_bsdf = -1; | 
| 200 |  | for (oy = 0; oy < sqres; oy++) { | 
| 201 | < | SDsquare2disk(ovec, (ox+.5)/sqres, (oy+.5)/sqres); | 
| 202 | < | ovec[2] = output_orient * | 
| 203 | < | sqrt(1. - ovec[0]*ovec[0] - ovec[1]*ovec[1]); | 
| 204 | < | bsdf = eval_rbfrep(rbf, ovec) / fabs(ovec[2]); | 
| 201 | > | 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 | > | 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 | > | if (assignD) { | 
| 217 | > | varset("Dx", '=', -iovec[3]); | 
| 218 | > | varset("Dy", '=', -iovec[4]); | 
| 219 | > | varset("Dz", '=', -iovec[5]); | 
| 220 | > | ++eclock; | 
| 221 | > | } | 
| 222 | > | bsdf = funvalue(funame, 6, iovec); | 
| 223 | > | #if (NSSAMP > 0) | 
| 224 | > | if (abs_diff(bsdf, last_bsdf) > ssamp_thresh) { | 
| 225 | > | 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 | > | 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 | > | if (assignD) { | 
| 241 | > | varset("Dx", '=', -ssvec[3]); | 
| 242 | > | varset("Dy", '=', -ssvec[4]); | 
| 243 | > | varset("Dz", '=', -ssvec[5]); | 
| 244 | > | ++eclock; | 
| 245 | > | } | 
| 246 | > | sum += funvalue(funame, 6, ssvec); | 
| 247 | > | } | 
| 248 | > | bsdf = sum/NSSAMP; | 
| 249 | > | } | 
| 250 | > | #endif | 
| 251 | > | } | 
| 252 |  | if (pctcull >= 0) | 
| 253 | < | fwrite(&bsdf, sizeof(bsdf), 1, ofp); | 
| 253 | > | putbinary(&bsdf, sizeof(bsdf), 1, ofp); | 
| 254 |  | else | 
| 255 | < | printf("\t%.3e\n", bsdf); | 
| 255 | > | fprintf(ofp, "\t%.3e\n", bsdf); | 
| 256 | > |  | 
| 257 | > | if (rbf_colorimetry == RBCtristimulus) { | 
| 258 | > | if (pctcull >= 0) { | 
| 259 | > | putbinary(&uv[0], sizeof(*uv), 1, uvfp[0]); | 
| 260 | > | putbinary(&uv[1], sizeof(*uv), 1, uvfp[1]); | 
| 261 | > | } else { | 
| 262 | > | fprintf(uvfp[0], "\t%.3e\n", uv[0]); | 
| 263 | > | fprintf(uvfp[1], "\t%.3e\n", uv[1]); | 
| 264 | > | } | 
| 265 | > | } | 
| 266 | > | last_bsdf = bsdf; | 
| 267 |  | } | 
| 268 | + | } | 
| 269 |  | if (rbf != NULL) | 
| 270 |  | free(rbf); | 
| 271 | + | prog_show((ix+1.)*(2./sqres)); | 
| 272 |  | } | 
| 273 | + | prog_done(); | 
| 274 |  | if (pctcull >= 0) {                     /* finish output */ | 
| 275 |  | if (pclose(ofp)) { | 
| 276 | < | fprintf(stderr, "%s: error running '%s'\n", | 
| 277 | < | progname, cmd); | 
| 276 | > | 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 | + | exit(1); | 
| 285 | + | } | 
| 286 |  | } else { | 
| 287 |  | for (ix = sqres*sqres*sqres/2; ix--; ) | 
| 288 | < | fputs("\t0\n", stdout); | 
| 289 | < | fputs("}\n", stdout); | 
| 288 | > | 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 = sqres*sqres*sqres/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 |  | } | 
| 309 |  | } | 
| 310 |  |  | 
| 311 |  | /* Interpolate and output anisotropic BSDF data */ | 
| 312 |  | static void | 
| 313 | < | interp_anisotropic() | 
| 313 | > | eval_anisotropic(char *funame) | 
| 314 |  | { | 
| 315 |  | const int       sqres = 1<<samp_order; | 
| 316 | < | FILE            *ofp = NULL; | 
| 316 | > | FILE            *ofp, *uvfp[2]; | 
| 317 | > | int             assignD = 0; | 
| 318 |  | char            cmd[128]; | 
| 319 |  | int             ix, iy, ox, oy; | 
| 320 | < | FVECT           ivec, ovec; | 
| 321 | < | double          bsdf; | 
| 322 | < | #if DEBUG | 
| 323 | < | fprintf(stderr, "Writing anisotropic order %d ", samp_order); | 
| 324 | < | if (pctcull >= 0) fprintf(stderr, "data with %d%% culling\n", pctcull); | 
| 325 | < | else fputs("raw data\n", stderr); | 
| 326 | < | #endif | 
| 327 | < | if (pctcull >= 0) {                     /* begin output */ | 
| 328 | < | sprintf(cmd, "rttree_reduce -h -a -fd -r 4 -t %d -g %d", | 
| 102 | < | pctcull, samp_order); | 
| 103 | < | fflush(stdout); | 
| 320 | > | double          iovec[6]; | 
| 321 | > | float           bsdf, uv[2]; | 
| 322 | > |  | 
| 323 | > | if (pctcull >= 0) { | 
| 324 | > | const char      *avgopt = (input_orient>0 ^ output_orient>0) | 
| 325 | > | ? "" : " -a"; | 
| 326 | > | sprintf(cmd, "rttree_reduce%s -h -ff -r 4 -t %f -g %d > %s", | 
| 327 | > | avgopt, pctcull, samp_order, | 
| 328 | > | create_component_file(0)); | 
| 329 |  | 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 | < | } else | 
| 336 | < | fputs("{\n", stdout); | 
| 335 | > | SET_FILE_BINARY(ofp); | 
| 336 | > | #ifdef getc_unlocked                            /* avoid lock/unlock overhead */ | 
| 337 | > | flockfile(ofp); | 
| 338 | > | #endif | 
| 339 | > | 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 | > | avgopt, uvcull, samp_order, | 
| 343 | > | create_component_file(1)); | 
| 344 | > | uvfp[0] = popen(cmd, "w"); | 
| 345 | > | sprintf(cmd, "rttree_reduce%s -h -ff -r 4 -t %f -g %d > %s", | 
| 346 | > | avgopt, uvcull, samp_order, | 
| 347 | > | create_component_file(2)); | 
| 348 | > | 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 | > | if (funame != NULL)                     /* need to assign Dx, Dy, Dz? */ | 
| 380 | > | assignD = (fundefined(funame) < 6); | 
| 381 |  | /* run through directions */ | 
| 382 |  | for (ix = 0; ix < sqres; ix++) | 
| 383 |  | for (iy = 0; iy < sqres; iy++) { | 
| 384 | < | RBFNODE *rbf; | 
| 385 | < | SDsquare2disk(ivec, (ix+.5)/sqres, (iy+.5)/sqres); | 
| 386 | < | ivec[2] = input_orient * | 
| 387 | < | sqrt(1. - ivec[0]*ivec[0] - ivec[1]*ivec[1]); | 
| 388 | < | rbf = advect_rbf(ivec); | 
| 389 | < | for (ox = 0; ox < sqres; ox++) | 
| 384 | > | RBFNODE *rbf = NULL;            /* Klems reversal */ | 
| 385 | > | SDsquare2disk(iovec, 1.-(ix+.5)/sqres, 1.-(iy+.5)/sqres); | 
| 386 | > | iovec[2] = input_orient * | 
| 387 | > | sqrt(1. - iovec[0]*iovec[0] - iovec[1]*iovec[1]); | 
| 388 | > | if (funame == NULL) | 
| 389 | > | rbf = advect_rbf(iovec, lobe_lim); | 
| 390 | > | for (ox = 0; ox < sqres; ox++) { | 
| 391 | > | float       last_bsdf = -1; | 
| 392 |  | for (oy = 0; oy < sqres; oy++) { | 
| 393 | < | SDsquare2disk(ovec, (ox+.5)/sqres, (oy+.5)/sqres); | 
| 394 | < | ovec[2] = output_orient * | 
| 395 | < | sqrt(1. - ovec[0]*ovec[0] - ovec[1]*ovec[1]); | 
| 396 | < | bsdf = eval_rbfrep(rbf, ovec) / fabs(ovec[2]); | 
| 393 | > | 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 | > | 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 | > | if (assignD) { | 
| 409 | > | varset("Dx", '=', -iovec[3]); | 
| 410 | > | varset("Dy", '=', -iovec[4]); | 
| 411 | > | varset("Dz", '=', -iovec[5]); | 
| 412 | > | ++eclock; | 
| 413 | > | } | 
| 414 | > | bsdf = funvalue(funame, 6, iovec); | 
| 415 | > | #if (NSSAMP > 0) | 
| 416 | > | if (abs_diff(bsdf, last_bsdf) > ssamp_thresh) { | 
| 417 | > | 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 | > | SDsquare2disk(ssvec, 1.-(ix+ssa[0])/sqres, | 
| 424 | > | 1.-(iy+ssa[1])/sqres); | 
| 425 | > | ssvec[2] = input_orient * | 
| 426 | > | 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 | > | if (assignD) { | 
| 434 | > | varset("Dx", '=', -ssvec[3]); | 
| 435 | > | varset("Dy", '=', -ssvec[4]); | 
| 436 | > | varset("Dz", '=', -ssvec[5]); | 
| 437 | > | ++eclock; | 
| 438 | > | } | 
| 439 | > | sum += funvalue(funame, 6, ssvec); | 
| 440 | > | } | 
| 441 | > | bsdf = sum/NSSAMP; | 
| 442 | > | } | 
| 443 | > | #endif | 
| 444 | > | } | 
| 445 |  | if (pctcull >= 0) | 
| 446 | < | fwrite(&bsdf, sizeof(bsdf), 1, ofp); | 
| 446 | > | putbinary(&bsdf, sizeof(bsdf), 1, ofp); | 
| 447 |  | else | 
| 448 | < | printf("\t%.3e\n", bsdf); | 
| 448 | > | fprintf(ofp, "\t%.3e\n", bsdf); | 
| 449 | > |  | 
| 450 | > | if (rbf_colorimetry == RBCtristimulus) { | 
| 451 | > | if (pctcull >= 0) { | 
| 452 | > | putbinary(&uv[0], sizeof(*uv), 1, uvfp[0]); | 
| 453 | > | putbinary(&uv[1], sizeof(*uv), 1, uvfp[1]); | 
| 454 | > | } else { | 
| 455 | > | fprintf(uvfp[0], "\t%.3e\n", uv[0]); | 
| 456 | > | fprintf(uvfp[1], "\t%.3e\n", uv[1]); | 
| 457 | > | } | 
| 458 | > | } | 
| 459 | > | last_bsdf = bsdf; | 
| 460 |  | } | 
| 461 | + | } | 
| 462 |  | if (rbf != NULL) | 
| 463 |  | free(rbf); | 
| 464 | + | prog_show((ix*sqres+iy+1.)/(sqres*sqres)); | 
| 465 |  | } | 
| 466 | + | prog_done(); | 
| 467 |  | if (pctcull >= 0) {                     /* finish output */ | 
| 468 |  | if (pclose(ofp)) { | 
| 469 | < | fprintf(stderr, "%s: error running '%s'\n", | 
| 470 | < | progname, cmd); | 
| 469 | > | fprintf(stderr, "%s: error running rttree_reduce on Y\n", | 
| 470 | > | progname); | 
| 471 |  | exit(1); | 
| 472 |  | } | 
| 473 | < | } else | 
| 474 | < | fputs("}\n", stdout); | 
| 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 | > | exit(1); | 
| 478 | > | } | 
| 479 | > | } 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 |  | } | 
| 497 |  |  | 
| 498 | + | #if defined(_WIN32) || defined(_WIN64) | 
| 499 | + | /* 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 |  | /* Read in BSDF and interpolate as tensor tree representation */ | 
| 555 |  | int | 
| 556 |  | main(int argc, char *argv[]) | 
| 557 |  | { | 
| 558 | < | FILE    *fpin = stdin; | 
| 559 | < | int     i; | 
| 558 | > | static char     tfmt[2][4] = {"t4", "t3"}; | 
| 559 | > | int     dofwd = 0, dobwd = 1; | 
| 560 | > | char    buf[2048]; | 
| 561 | > | int     i, na; | 
| 562 |  |  | 
| 563 | < | progname = argv[0];                     /* get options */ | 
| 564 | < | while (argc > 2 && argv[1][0] == '-') { | 
| 565 | < | switch (argv[1][1]) { | 
| 563 | > | progname = argv[0]; | 
| 564 | > | 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 | > | 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 | > | dofwd = (argv[i][0] == '+'); | 
| 582 | > | break; | 
| 583 | > | case 'b': | 
| 584 | > | dobwd = (argv[i][0] == '+'); | 
| 585 | > | break; | 
| 586 |  | case 't': | 
| 587 | < | pctcull = atoi(argv[2]); | 
| 587 | > | switch (argv[i][2]) { | 
| 588 | > | case '3': | 
| 589 | > | single_plane_incident = 1; | 
| 590 | > | break; | 
| 591 | > | case '4': | 
| 592 | > | single_plane_incident = 0; | 
| 593 | > | break; | 
| 594 | > | case '\0': | 
| 595 | > | pctcull = atof(argv[++i]); | 
| 596 | > | break; | 
| 597 | > | default: | 
| 598 | > | goto userr; | 
| 599 | > | } | 
| 600 |  | break; | 
| 601 |  | case 'g': | 
| 602 | < | samp_order = atoi(argv[2]); | 
| 602 | > | samp_order = atoi(argv[++i]); | 
| 603 |  | break; | 
| 604 | + | case 'l': | 
| 605 | + | lobe_lim = atoi(argv[++i]); | 
| 606 | + | break; | 
| 607 | + | case 'p': | 
| 608 | + | do_prog = atoi(argv[i]+2); | 
| 609 | + | break; | 
| 610 | + | 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 |  | default: | 
| 619 |  | goto userr; | 
| 620 |  | } | 
| 621 | < | argv += 2; argc -= 2; | 
| 621 | > | 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 | < | if (argc == 2) {                        /* open input if given */ | 
| 626 | < | fpin = fopen(argv[1], "r"); | 
| 627 | < | if (fpin == NULL) { | 
| 628 | < | fprintf(stderr, "%s: cannot open BSDF interpolant '%s'\n", | 
| 629 | < | progname, argv[1]); | 
| 630 | < | return(1); | 
| 625 | > | if (single_plane_incident >= 0) {       /* function-based BSDF? */ | 
| 626 | > | void    (*evf)(char *s) = single_plane_incident ? | 
| 627 | > | eval_isotropic : eval_anisotropic; | 
| 628 | > | if (i != argc-1 || fundefined(argv[i]) < 3) { | 
| 629 | > | fprintf(stderr, | 
| 630 | > | "%s: need single function with 6 arguments: bsdf(ix,iy,iz,ox,oy,oz)\n", | 
| 631 | > | progname); | 
| 632 | > | fprintf(stderr, "\tor 3 arguments using Dx,Dy,Dz: bsdf(ix,iy,iz)\n"); | 
| 633 | > | goto userr; | 
| 634 |  | } | 
| 635 | < | } else if (argc != 1) | 
| 636 | < | goto userr; | 
| 637 | < | SET_FILE_BINARY(fpin);                  /* load BSDF interpolant */ | 
| 638 | < | if (!load_bsdf_rep(fpin)) | 
| 635 | > | ++eclock; | 
| 636 | > | add_wbsdf("-a", 1); | 
| 637 | > | add_wbsdf(tfmt[single_plane_incident], 1); | 
| 638 | > | if (dofwd) { | 
| 639 | > | input_orient = -1; | 
| 640 | > | output_orient = -1; | 
| 641 | > | prog_start("Evaluating outside reflectance"); | 
| 642 | > | (*evf)(argv[i]); | 
| 643 | > | output_orient = 1; | 
| 644 | > | prog_start("Evaluating outside->inside transmission"); | 
| 645 | > | (*evf)(argv[i]); | 
| 646 | > | } | 
| 647 | > | if (dobwd) { | 
| 648 | > | input_orient = 1; | 
| 649 | > | output_orient = 1; | 
| 650 | > | prog_start("Evaluating inside reflectance"); | 
| 651 | > | (*evf)(argv[i]); | 
| 652 | > | output_orient = -1; | 
| 653 | > | prog_start("Evaluating inside->outside transmission"); | 
| 654 | > | (*evf)(argv[i]); | 
| 655 | > | } | 
| 656 | > | return(wrap_up()); | 
| 657 | > | } | 
| 658 | > | if (i < argc) {                         /* open input files if given */ | 
| 659 | > | int     nbsdf = 0; | 
| 660 | > | for ( ; i < argc; i++) {        /* interpolate each component */ | 
| 661 | > | char    pbuf[256]; | 
| 662 | > | 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 | > | sprintf(pbuf, "Interpolating component '%s'", argv[i]); | 
| 672 | > | prog_start(pbuf); | 
| 673 | > | if (!nbsdf++) { | 
| 674 | > | add_wbsdf("-a", 1); | 
| 675 | > | add_wbsdf(tfmt[single_plane_incident], 1); | 
| 676 | > | } | 
| 677 | > | if (single_plane_incident) | 
| 678 | > | eval_isotropic(NULL); | 
| 679 | > | else | 
| 680 | > | eval_anisotropic(NULL); | 
| 681 | > | } | 
| 682 | > | return(wrap_up()); | 
| 683 | > | } | 
| 684 | > | SET_FILE_BINARY(stdin);                 /* load from stdin */ | 
| 685 | > | if (!load_bsdf_rep(stdin)) | 
| 686 |  | return(1); | 
| 687 | < | /* xml_prologue();                              /* start XML output */ | 
| 687 | > | prog_start("Interpolating from standard input"); | 
| 688 | > | add_wbsdf("-a", 1); | 
| 689 | > | add_wbsdf(tfmt[single_plane_incident], 1); | 
| 690 |  | if (single_plane_incident)              /* resample dist. */ | 
| 691 | < | interp_isotropic(); | 
| 691 | > | eval_isotropic(NULL); | 
| 692 |  | else | 
| 693 | < | interp_anisotropic(); | 
| 694 | < | /* xml_epilogue();                              /* finish XML output */ | 
| 695 | < | return(0); | 
| 693 | > | eval_anisotropic(NULL); | 
| 694 | > |  | 
| 695 | > | return(wrap_up()); | 
| 696 |  | userr: | 
| 697 |  | fprintf(stderr, | 
| 698 | < | "Usage: %s [-t pctcull][-g log2grid] [bsdf.sir] > bsdf.xml\n", | 
| 698 | > | "Usage: %s [-g Nlog2][-t pctcull][-l maxlobes] [bsdf.sir ..] > bsdf.xml\n", | 
| 699 | > | 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 |  | progname); | 
| 703 |  | return(1); | 
| 704 |  | } |