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

Comparing ray/src/cv/bsdf2ttree.c (file contents):
Revision 2.27 by greg, Wed Mar 12 22:24:59 2014 UTC vs.
Revision 2.30 by greg, Tue May 5 22:16:49 2015 UTC

# Line 25 | Line 25 | int                    samp_order = 6;
25                                  /* super-sampling threshold */
26   const double            ssamp_thresh = 0.35;
27                                  /* number of super-samples */
28 < const int               nssamp = 100;
28 > #ifndef NSSAMP
29 > #define NSSAMP          100
30 > #endif
31                                  /* limit on number of RBF lobes */
32   static int              lobe_lim = 15000;
33                                  /* progress bar length */
# Line 39 | Line 41 | static int             do_prog = 79;
41   static void
42   prog_show(double frac)
43   {
44 <        char    pbar[256];
45 <        int     nchars;
44 >        static unsigned call_cnt = 0;
45 >        static char     lastc[] = "-\\|/";
46 >        char            pbar[256];
47 >        int             nchars;
48  
49 <        if (do_prog <= 0) return;
49 >        if (do_prog <= 1) return;
50          if (do_prog > sizeof(pbar)-2)
51                  do_prog = sizeof(pbar)-2;
52          if (frac < 0) frac = 0;
53 <        else if (frac > 1) frac = 1;
54 <        nchars = do_prog*frac + .5;
53 >        else if (frac >= 1) frac = .9999;
54 >        nchars = do_prog*frac;
55          pbar[0] = '\r';
56          memset(pbar+1, '*', nchars);
57 <        memset(pbar+1+nchars, '-', do_prog-nchars);
57 >        pbar[nchars+1] = lastc[call_cnt++ & 3];
58 >        memset(pbar+2+nchars, '-', do_prog-nchars-1);
59          pbar[do_prog+1] = '\0';
60          fputs(pbar, stderr);
61   }
# Line 197 | Line 202 | eval_isotropic(char *funame)
202                          iovec[5] = output_orient *
203                                  sqrt(1. - iovec[3]*iovec[3] - iovec[4]*iovec[4]);
204                          if (funame == NULL)
205 <                            bsdf = eval_rbfrep(rbf, iovec+3) *
201 <                                                output_orient/iovec[5];
205 >                            bsdf = eval_rbfrep(rbf, iovec+3);
206                          else {
203 –                            double      ssa[3], ssvec[6], sum;
204 –                            int         ssi;
207                              if (assignD) {
208                                  varset("Dx", '=', -iovec[3]);
209                                  varset("Dy", '=', -iovec[4]);
# Line 209 | Line 211 | eval_isotropic(char *funame)
211                                  ++eclock;
212                              }
213                              bsdf = funvalue(funame, 6, iovec);
214 + #if (NSSAMP > 0)
215                              if (abs_diff(bsdf, last_bsdf) > ssamp_thresh) {
216 <                                sum = 0;        /* super-sample voxel */
217 <                                for (ssi = nssamp; ssi--; ) {
218 <                                    SDmultiSamp(ssa, 3, (ssi+frandom())/nssamp);
216 >                                int     ssi;
217 >                                double  ssa[3], ssvec[6], sum = 0;
218 >                                                /* super-sample voxel */
219 >                                for (ssi = NSSAMP; ssi--; ) {
220 >                                    SDmultiSamp(ssa, 3, (ssi+frandom()) *
221 >                                                        (1./NSSAMP));
222                                      ssvec[0] = 2.*(ix+ssa[0])/sqres - 1.;
223                                      ssvec[1] = .0;
224                                      ssvec[2] = input_orient *
# Line 223 | Line 229 | eval_isotropic(char *funame)
229                                                  sqrt(1. - ssvec[3]*ssvec[3] -
230                                                          ssvec[4]*ssvec[4]);
231                                      if (assignD) {
232 <                                        varset("Dx", '=', -iovec[3]);
233 <                                        varset("Dy", '=', -iovec[4]);
234 <                                        varset("Dz", '=', -iovec[5]);
232 >                                        varset("Dx", '=', -ssvec[3]);
233 >                                        varset("Dy", '=', -ssvec[4]);
234 >                                        varset("Dz", '=', -ssvec[5]);
235                                          ++eclock;
236                                      }
237                                      sum += funvalue(funame, 6, ssvec);
238                                  }
239 <                                bsdf = sum/nssamp;
239 >                                bsdf = sum/NSSAMP;
240                              }
241 + #endif
242                          }
243                          if (pctcull >= 0)
244                                  fwrite(&bsdf, sizeof(bsdf), 1, ofp);
# Line 308 | Line 315 | eval_anisotropic(char *funame)
315                          iovec[5] = output_orient *
316                                  sqrt(1. - iovec[3]*iovec[3] - iovec[4]*iovec[4]);
317                          if (funame == NULL)
318 <                            bsdf = eval_rbfrep(rbf, iovec+3) *
312 <                                                output_orient/iovec[5];
318 >                            bsdf = eval_rbfrep(rbf, iovec+3);
319                          else {
314 –                            double      ssa[4], ssvec[6], sum;
315 –                            int         ssi;
320                              if (assignD) {
321                                  varset("Dx", '=', -iovec[3]);
322                                  varset("Dy", '=', -iovec[4]);
# Line 320 | Line 324 | eval_anisotropic(char *funame)
324                                  ++eclock;
325                              }
326                              bsdf = funvalue(funame, 6, iovec);
327 + #if (NSSAMP > 0)
328                              if (abs_diff(bsdf, last_bsdf) > ssamp_thresh) {
329 <                                sum = 0;        /* super-sample voxel */
330 <                                for (ssi = nssamp; ssi--; ) {
331 <                                    SDmultiSamp(ssa, 4, (ssi+frandom())/nssamp);
329 >                                int     ssi;
330 >                                double  ssa[4], ssvec[6], sum = 0;
331 >                                                /* super-sample voxel */
332 >                                for (ssi = NSSAMP; ssi--; ) {
333 >                                    SDmultiSamp(ssa, 4, (ssi+frandom()) *
334 >                                                        (1./NSSAMP));
335                                      SDsquare2disk(ssvec, 1.-(ix+ssa[0])/sqres,
336                                                  1.-(iy+ssa[1])/sqres);
337 <                                    ssvec[2] = output_orient *
337 >                                    ssvec[2] = input_orient *
338                                                  sqrt(1. - ssvec[0]*ssvec[0] -
339                                                          ssvec[1]*ssvec[1]);
340                                      SDsquare2disk(ssvec+3, (ox+ssa[2])/sqres,
# Line 335 | Line 343 | eval_anisotropic(char *funame)
343                                                  sqrt(1. - ssvec[3]*ssvec[3] -
344                                                          ssvec[4]*ssvec[4]);
345                                      if (assignD) {
346 <                                        varset("Dx", '=', -iovec[3]);
347 <                                        varset("Dy", '=', -iovec[4]);
348 <                                        varset("Dz", '=', -iovec[5]);
346 >                                        varset("Dx", '=', -ssvec[3]);
347 >                                        varset("Dy", '=', -ssvec[4]);
348 >                                        varset("Dz", '=', -ssvec[5]);
349                                          ++eclock;
350                                      }
351                                      sum += funvalue(funame, 6, ssvec);
352                                  }
353 <                                bsdf = sum/nssamp;
353 >                                bsdf = sum/NSSAMP;
354                              }
355 + #endif
356                          }
357                          if (pctcull >= 0)
358                                  fwrite(&bsdf, sizeof(bsdf), 1, ofp);

Diff Legend

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