ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/cv/bsdf2klems.c
(Generate patch)

Comparing ray/src/cv/bsdf2klems.c (file contents):
Revision 2.7 by greg, Thu Aug 1 16:10:13 2013 UTC vs.
Revision 2.13 by greg, Wed Mar 12 21:15:31 2014 UTC

# Line 25 | Line 25 | char                   *progname;
25   static const char       *kbasis = "LBNL/Klems Full";
26                                  /* number of BSDF samples per patch */
27   static int              npsamps = 256;
28 +                                /* limit on number of RBF lobes */
29 + static int              lobe_lim = 15000;
30 +                                /* progress bar length */
31 + static int              do_prog = 79;
32  
33 +
34 + /* Start new progress bar */
35 + #define prog_start(s)   if (do_prog) fprintf(stderr, "%s: %s...\n", progname, s); else
36 +
37 + /* Draw progress bar of the appropriate length */
38 + static void
39 + prog_show(double frac)
40 + {
41 +        char    pbar[256];
42 +        int     nchars;
43 +
44 +        if (do_prog <= 0) return;
45 +        if (do_prog > sizeof(pbar)-2)
46 +                do_prog = sizeof(pbar)-2;
47 +        if (frac < 0) frac = 0;
48 +        else if (frac > 1) frac = 1;
49 +        nchars = do_prog*frac + .5;
50 +        pbar[0] = '\r';
51 +        memset(pbar+1, '*', nchars);
52 +        memset(pbar+1+nchars, '-', do_prog-nchars);
53 +        pbar[do_prog+1] = '\0';
54 +        fputs(pbar, stderr);
55 + }
56 +
57 + /* Finish progress bar */
58 + #define prog_done()     if (do_prog) fputc('\n',stderr); else
59 +
60   /* Return angle basis corresponding to the given name */
61 < ANGLE_BASIS *
61 > static ANGLE_BASIS *
62   get_basis(const char *bn)
63   {
64          int     n = nabases;
# Line 56 | Line 87 | xml_header(int ac, char *av[])
87   static void
88   xml_prologue(const SDData *sd)
89   {
90 <        const char      *matn = (sd && sd->matn[0]) ? sd->matn : "Name";
91 <        const char      *makr = (sd && sd->makr[0]) ? sd->makr : "Manufacturer";
90 >        const char      *matn = (sd && sd->matn[0]) ? sd->matn :
91 >                                bsdf_name[0] ? bsdf_name : "Unknown";
92 >        const char      *makr = (sd && sd->makr[0]) ? sd->makr :
93 >                                bsdf_manuf[0] ? bsdf_manuf : "Unknown";
94          ANGLE_BASIS     *abp = get_basis(kbasis);
95          int             i;
96  
# Line 154 | Line 187 | static void
187   eval_bsdf(const char *fname)
188   {
189          ANGLE_BASIS     *abp = get_basis(kbasis);
157 –        float           *trans_mtx = NULL;
190          SDData          bsd;
191          SDError         ec;
192          FVECT           vin, vout;
# Line 210 | Line 242 | eval_bsdf(const char *fname)
242          }
243                                                  /* front transmission */
244          if (bsd.tf != NULL || bsd.tLamb.cieY > .002) {
213 –            if (bsd.tb == NULL)
214 –                trans_mtx = (float *)malloc(sizeof(float) *
215 –                                                abp->nangles*abp->nangles);
245              input_orient = 1; output_orient = -1;
246              data_prologue();
247              for (j = 0; j < abp->nangles; j++) {
# Line 227 | Line 256 | eval_bsdf(const char *fname)
256                          sum += sv.cieY;
257                      }
258                      printf("\t%.3e\n", sum/npsamps);
230 –                    if (trans_mtx != NULL)
231 –                        trans_mtx[j*abp->nangles + i] = sum/npsamps;
259                  }
260                  putchar('\n');                  /* extra space between rows */
261              }
262              data_epilogue();
263          }
264                                                  /* back transmission */
265 <        if (bsd.tb != NULL || trans_mtx != NULL) {
239 <            if (bsd.tf == NULL)
240 <                trans_mtx = (float *)malloc(sizeof(float) *
241 <                                                abp->nangles*abp->nangles);
265 >        if ((bsd.tb != NULL) | (bsd.tf != NULL)) {
266              input_orient = -1; output_orient = 1;
267              data_prologue();
268              for (j = 0; j < abp->nangles; j++) {
269 <                for (i = 0; i < abp->nangles; i++)
270 <                    if (bsd.tb != NULL) {       /* use tb if we have it */
271 <                        sum = 0;                /* average over patches */
272 <                        for (n = npsamps; n-- > 0; ) {
273 <                            fo_getvec(vout, j+(n+frandom())/npsamps, abp);
274 <                            bi_getvec(vin, i+urand(n), abp);
275 <                            ec = SDevalBSDF(&sv, vout, vin, &bsd);
252 <                            if (ec != SDEnone)
269 >                for (i = 0; i < abp->nangles; i++) {
270 >                    sum = 0;            /* average over patches */
271 >                    for (n = npsamps; n-- > 0; ) {
272 >                        fo_getvec(vout, j+(n+frandom())/npsamps, abp);
273 >                        bi_getvec(vin, i+urand(n), abp);
274 >                        ec = SDevalBSDF(&sv, vout, vin, &bsd);
275 >                        if (ec != SDEnone)
276                                  goto err;
277 <                            sum += sv.cieY;
255 <                        }
256 <                        printf("\t%.3e\n", sum/npsamps);
257 <                        if (trans_mtx != NULL)
258 <                            trans_mtx[i*abp->nangles + j] = sum/npsamps;
259 <                    } else {                    /* else transpose tf */
260 <                        printf("\t%.3e\n", trans_mtx[i*abp->nangles + j]);
277 >                        sum += sv.cieY;
278                      }
279 +                    printf("\t%.3e\n", sum/npsamps);
280 +                }
281                  putchar('\n');                  /* extra space between rows */
282              }
283              data_epilogue();
284          }
266 –                                                /* derived front transmission */
267 –        if (bsd.tf == NULL && trans_mtx != NULL) {
268 –            input_orient = 1; output_orient = -1;
269 –            data_prologue();
270 –            for (j = 0; j < abp->nangles; j++) {
271 –                for (i = 0; i < abp->nangles; i++)
272 –                    printf("\t%.3e\n", trans_mtx[j*abp->nangles + i]);
273 –                putchar('\n');                  /* extra space between rows */
274 –            }
275 –            data_epilogue();
276 –        }
285          SDfreeBSDF(&bsd);                       /* all done */
278 –        if (trans_mtx != NULL)
279 –                free(trans_mtx);
286          return;
287   err:
288          SDreportError(ec, stderr);
# Line 288 | Line 294 | static void
294   eval_function(char *funame)
295   {
296          ANGLE_BASIS     *abp = get_basis(kbasis);
297 +        int             assignD = (fundefined(funame) < 6);
298          double          iovec[6];
299          double          sum;
300          int             i, j, n;
# Line 308 | Line 315 | eval_function(char *funame)
315                      else
316                          bi_getvec(iovec, i+urand(n), abp);
317  
318 +                    if (assignD) {
319 +                        varset("Dx", '=', -iovec[3]);
320 +                        varset("Dy", '=', -iovec[4]);
321 +                        varset("Dz", '=', -iovec[5]);
322 +                        ++eclock;
323 +                    }
324                      sum += funvalue(funame, 6, iovec);
325                  }
326                  printf("\t%.3e\n", sum/npsamps);
327              }
328              putchar('\n');
329 +            prog_show((j+1.)/abp->nangles);
330          }
331          data_epilogue();                        /* finish output */
332 +        prog_done();
333   }
334  
335   /* Interpolate and output a radial basis function BSDF representation */
# Line 339 | Line 354 | eval_rbf(void)
354              else
355                  bi_getvec(vin, i+.5*(i>0), abp);
356  
357 <            rbf = advect_rbf(vin);              /* compute radial basis func */
357 >            rbf = advect_rbf(vin, lobe_lim);    /* compute radial basis func */
358  
359              for (j = 0; j < abp->nangles; j++) {
360                  sum = 0;                        /* sample over exiting patch */
# Line 349 | Line 364 | eval_rbf(void)
364                      else
365                          bo_getvec(vout, j+(n+frandom())/npsamps, abp);
366  
367 <                    sum += eval_rbfrep(rbf, vout) / vout[2];
367 >                    sum += eval_rbfrep(rbf, vout);
368                  }
369 <                bsdfarr[j*abp->nangles + i] = sum*output_orient/npsamps;
369 >                fo_getvec(vout, j+.5, abp);     /* use centered secant */
370 >                bsdfarr[j*abp->nangles + i] = sum / (npsamps*vout[2]);
371              }
372              if (rbf != NULL)
373                  free(rbf);
374 +            prog_show((i+1.)/abp->nangles);
375          }
376          n = 0;                                  /* write out our matrix */
377          for (j = 0; j < abp->nangles; j++) {
# Line 363 | Line 380 | eval_rbf(void)
380              putchar('\n');
381          }
382          data_epilogue();                        /* finish output */
383 +        prog_done();
384   }
385  
386   /* Read in BSDF and interpolate as Klems matrix representation */
# Line 405 | Line 423 | main(int argc, char *argv[])
423                  case 'q':
424                          kbasis = "LBNL/Klems Quarter";
425                          break;
426 +                case 'l':
427 +                        lobe_lim = atoi(argv[++i]);
428 +                        break;
429 +                case 'p':
430 +                        do_prog = atoi(argv[i]+2);
431 +                        break;
432                  default:
433                          goto userr;
434                  }
# Line 413 | Line 437 | main(int argc, char *argv[])
437                          fprintf(stderr,
438          "%s: need single function with 6 arguments: bsdf(ix,iy,iz,ox,oy,oz)\n",
439                                          progname);
440 +                        fprintf(stderr, "\tor 3 arguments using Dx,Dy,Dz: bsdf(ix,iy,iz)\n");
441                          goto userr;
442                  }
443 +                ++eclock;
444                  xml_header(argc, argv);                 /* start XML output */
445                  xml_prologue(NULL);
446                  if (dofwd) {
447                          input_orient = -1;
448                          output_orient = -1;
449 <                        eval_function(argv[i]);         /* outside reflectance */
449 >                        prog_start("Evaluating outside reflectance");
450 >                        eval_function(argv[i]);
451                          output_orient = 1;
452 <                        eval_function(argv[i]);         /* outside -> inside */
452 >                        prog_start("Evaluating outside->inside transmission");
453 >                        eval_function(argv[i]);
454                  }
455                  if (dobwd) {
456                          input_orient = 1;
457                          output_orient = 1;
458 <                        eval_function(argv[i]);         /* inside reflectance */
458 >                        prog_start("Evaluating inside reflectance");
459 >                        eval_function(argv[i]);
460                          output_orient = -1;
461 <                        eval_function(argv[i]);         /* inside -> outside */
461 >                        prog_start("Evaluating inside->outside transmission");
462 >                        eval_function(argv[i]);
463                  }
464                  xml_epilogue();                 /* finish XML output & exit */
465                  return(0);
# Line 445 | Line 475 | main(int argc, char *argv[])
475          if (i < argc) {                         /* open input files if given */
476                  int     nbsdf = 0;
477                  for ( ; i < argc; i++) {        /* interpolate each component */
478 +                        char    pbuf[256];
479                          FILE    *fpin = fopen(argv[i], "rb");
480                          if (fpin == NULL) {
481                                  fprintf(stderr, "%s: cannot open BSDF interpolant '%s'\n",
# Line 458 | Line 489 | main(int argc, char *argv[])
489                                  xml_header(argc, argv);
490                                  xml_prologue(NULL);
491                          }
492 +                        sprintf(pbuf, "Interpolating component '%s'", argv[i]);
493 +                        prog_start(pbuf);
494                          eval_rbf();
495                  }
496                  xml_epilogue();                 /* finish XML output & exit */
# Line 468 | Line 501 | main(int argc, char *argv[])
501                  return(1);
502          xml_header(argc, argv);                 /* start XML output */
503          xml_prologue(NULL);
504 +        prog_start("Interpolating from standard input");
505          eval_rbf();                             /* resample dist. */
506          xml_epilogue();                         /* finish XML output & exit */
507          return(0);
508   userr:
509          fprintf(stderr,
510 <        "Usage: %s [-n spp][-h|-q][bsdf.sir ..] > bsdf.xml\n", progname);
510 >        "Usage: %s [-n spp][-h|-q][-l maxlobes] [bsdf.sir ..] > bsdf.xml\n", progname);
511          fprintf(stderr,
512          "   or: %s [-n spp][-h|-q] bsdf_in.xml > bsdf_out.xml\n", progname);
513          fprintf(stderr,

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines