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.9 by greg, Sun Aug 11 14:32:34 2013 UTC vs.
Revision 2.18 by greg, Wed May 27 11:39:37 2015 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 +        static unsigned call_cnt = 0;
42 +        static char     lastc[] = "-\\|/";
43 +        char            pbar[256];
44 +        int             nchars;
45 +
46 +        if (do_prog <= 1) return;
47 +        if (do_prog > sizeof(pbar)-2)
48 +                do_prog = sizeof(pbar)-2;
49 +        if (frac < 0) frac = 0;
50 +        else if (frac >= 1) frac = .9999;
51 +        nchars = do_prog*frac;
52 +        pbar[0] = '\r';
53 +        memset(pbar+1, '*', nchars);
54 +        pbar[nchars+1] = lastc[call_cnt++ & 3];
55 +        memset(pbar+2+nchars, '-', do_prog-nchars-1);
56 +        pbar[do_prog+1] = '\0';
57 +        fputs(pbar, stderr);
58 + }
59 +
60 + /* Finish progress bar */
61 + static void
62 + prog_done(void)
63 + {
64 +        int     n = do_prog;
65 +
66 +        if (n <= 1) return;
67 +        fputc('\r', stderr);
68 +        while (n--)
69 +                fputc(' ', stderr);
70 +        fputc('\r', stderr);
71 + }
72 +
73   /* Return angle basis corresponding to the given name */
74 < ANGLE_BASIS *
74 > static ANGLE_BASIS *
75   get_basis(const char *bn)
76   {
77          int     n = nabases;
# Line 56 | Line 100 | xml_header(int ac, char *av[])
100   static void
101   xml_prologue(const SDData *sd)
102   {
103 <        const char      *matn = (sd && sd->matn[0]) ? sd->matn : "Name";
104 <        const char      *makr = (sd && sd->makr[0]) ? sd->makr : "Manufacturer";
103 >        const char      *matn = (sd && sd->matn[0]) ? sd->matn :
104 >                                bsdf_name[0] ? bsdf_name : "Unknown";
105 >        const char      *makr = (sd && sd->makr[0]) ? sd->makr :
106 >                                bsdf_manuf[0] ? bsdf_manuf : "Unknown";
107          ANGLE_BASIS     *abp = get_basis(kbasis);
108          int             i;
109  
# Line 161 | Line 207 | eval_bsdf(const char *fname)
207          double          sum;
208          int             i, j, n;
209  
210 +        initurand(npsamps);
211          SDclearBSDF(&bsd, fname);               /* load BSDF file */
212          if ((ec = SDloadFile(&bsd, fname)) != SDEnone)
213                  goto err;
# Line 293 | Line 340 | eval_function(char *funame)
340                  printf("\t%.3e\n", sum/npsamps);
341              }
342              putchar('\n');
343 +            prog_show((j+1.)/abp->nangles);
344          }
345          data_epilogue();                        /* finish output */
346 +        prog_done();
347   }
348  
349   /* Interpolate and output a radial basis function BSDF representation */
# Line 319 | Line 368 | eval_rbf(void)
368              else
369                  bi_getvec(vin, i+.5*(i>0), abp);
370  
371 <            rbf = advect_rbf(vin);              /* compute radial basis func */
371 >            rbf = advect_rbf(vin, lobe_lim);    /* compute radial basis func */
372  
373              for (j = 0; j < abp->nangles; j++) {
374                  sum = 0;                        /* sample over exiting patch */
# Line 329 | Line 378 | eval_rbf(void)
378                      else
379                          bo_getvec(vout, j+(n+frandom())/npsamps, abp);
380  
381 <                    sum += eval_rbfrep(rbf, vout) / vout[2];
381 >                    sum += eval_rbfrep(rbf, vout);
382                  }
383 <                bsdfarr[j*abp->nangles + i] = sum*output_orient/npsamps;
383 >                bsdfarr[j*abp->nangles + i] = sum / (double)npsamps;
384              }
385              if (rbf != NULL)
386                  free(rbf);
387 +            prog_show((i+1.)/abp->nangles);
388          }
389          n = 0;                                  /* write out our matrix */
390          for (j = 0; j < abp->nangles; j++) {
# Line 343 | Line 393 | eval_rbf(void)
393              putchar('\n');
394          }
395          data_epilogue();                        /* finish output */
396 +        prog_done();
397   }
398  
399   /* Read in BSDF and interpolate as Klems matrix representation */
# Line 385 | Line 436 | main(int argc, char *argv[])
436                  case 'q':
437                          kbasis = "LBNL/Klems Quarter";
438                          break;
439 +                case 'l':
440 +                        lobe_lim = atoi(argv[++i]);
441 +                        break;
442 +                case 'p':
443 +                        do_prog = atoi(argv[i]+2);
444 +                        break;
445                  default:
446                          goto userr;
447                  }
# Line 393 | Line 450 | main(int argc, char *argv[])
450                          fprintf(stderr,
451          "%s: need single function with 6 arguments: bsdf(ix,iy,iz,ox,oy,oz)\n",
452                                          progname);
453 <                        fprintf(stderr, "\tor 3 arguments using Dx,Dy,Dz: bsdf(ix,iy,iz)\n",
397 <                                        progname);
453 >                        fprintf(stderr, "\tor 3 arguments using Dx,Dy,Dz: bsdf(ix,iy,iz)\n");
454                          goto userr;
455                  }
456                  ++eclock;
# Line 403 | Line 459 | main(int argc, char *argv[])
459                  if (dofwd) {
460                          input_orient = -1;
461                          output_orient = -1;
462 <                        eval_function(argv[i]);         /* outside reflectance */
462 >                        prog_start("Evaluating outside reflectance");
463 >                        eval_function(argv[i]);
464                          output_orient = 1;
465 <                        eval_function(argv[i]);         /* outside -> inside */
465 >                        prog_start("Evaluating outside->inside transmission");
466 >                        eval_function(argv[i]);
467                  }
468                  if (dobwd) {
469                          input_orient = 1;
470                          output_orient = 1;
471 <                        eval_function(argv[i]);         /* inside reflectance */
471 >                        prog_start("Evaluating inside reflectance");
472 >                        eval_function(argv[i]);
473                          output_orient = -1;
474 <                        eval_function(argv[i]);         /* inside -> outside */
474 >                        prog_start("Evaluating inside->outside transmission");
475 >                        eval_function(argv[i]);
476                  }
477                  xml_epilogue();                 /* finish XML output & exit */
478                  return(0);
# Line 428 | Line 488 | main(int argc, char *argv[])
488          if (i < argc) {                         /* open input files if given */
489                  int     nbsdf = 0;
490                  for ( ; i < argc; i++) {        /* interpolate each component */
491 +                        char    pbuf[256];
492                          FILE    *fpin = fopen(argv[i], "rb");
493                          if (fpin == NULL) {
494                                  fprintf(stderr, "%s: cannot open BSDF interpolant '%s'\n",
# Line 441 | Line 502 | main(int argc, char *argv[])
502                                  xml_header(argc, argv);
503                                  xml_prologue(NULL);
504                          }
505 +                        sprintf(pbuf, "Interpolating component '%s'", argv[i]);
506 +                        prog_start(pbuf);
507                          eval_rbf();
508                  }
509                  xml_epilogue();                 /* finish XML output & exit */
# Line 451 | Line 514 | main(int argc, char *argv[])
514                  return(1);
515          xml_header(argc, argv);                 /* start XML output */
516          xml_prologue(NULL);
517 +        prog_start("Interpolating from standard input");
518          eval_rbf();                             /* resample dist. */
519          xml_epilogue();                         /* finish XML output & exit */
520          return(0);
521   userr:
522          fprintf(stderr,
523 <        "Usage: %s [-n spp][-h|-q][bsdf.sir ..] > bsdf.xml\n", progname);
523 >        "Usage: %s [-n spp][-h|-q][-l maxlobes] [bsdf.sir ..] > bsdf.xml\n", progname);
524          fprintf(stderr,
525          "   or: %s [-n spp][-h|-q] bsdf_in.xml > bsdf_out.xml\n", progname);
526          fprintf(stderr,

Diff Legend

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