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.26 by greg, Wed Mar 12 21:15:31 2014 UTC vs.
Revision 2.32 by greg, Tue Feb 2 18:02:32 2016 UTC

# Line 19 | Line 19 | static const char RCSid[] = "$Id$";
19                                  /* global argv[0] */
20   char                    *progname;
21                                  /* percentage to cull (<0 to turn off) */
22 < double                  pctcull = 90.;
22 > static double           pctcull = 90.;
23                                  /* sampling order */
24 < int                     samp_order = 6;
24 > static 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 */
34   static int              do_prog = 79;
35  
36  
37 +
38   /* Start new progress bar */
39   #define prog_start(s)   if (do_prog) fprintf(stderr, "%s: %s...\n", progname, s); else
40  
# Line 39 | Line 42 | static int             do_prog = 79;
42   static void
43   prog_show(double frac)
44   {
45 <        char    pbar[256];
46 <        int     nchars;
45 >        static unsigned call_cnt = 0;
46 >        static char     lastc[] = "-\\|/";
47 >        char            pbar[256];
48 >        int             nchars;
49  
50 <        if (do_prog <= 0) return;
50 >        if (do_prog <= 1) return;
51          if (do_prog > sizeof(pbar)-2)
52                  do_prog = sizeof(pbar)-2;
53          if (frac < 0) frac = 0;
54 <        else if (frac > 1) frac = 1;
55 <        nchars = do_prog*frac + .5;
54 >        else if (frac >= 1) frac = .9999;
55 >        nchars = do_prog*frac;
56          pbar[0] = '\r';
57          memset(pbar+1, '*', nchars);
58 <        memset(pbar+1+nchars, '-', do_prog-nchars);
58 >        pbar[nchars+1] = lastc[call_cnt++ & 3];
59 >        memset(pbar+2+nchars, '-', do_prog-nchars-1);
60          pbar[do_prog+1] = '\0';
61          fputs(pbar, stderr);
62   }
63  
64   /* Finish progress bar */
59 – #define prog_done()     if (do_prog) fputc('\n',stderr); else
60 –
61 – /* Output XML prologue to stdout */
65   static void
66 < xml_prologue(int ac, char *av[])
66 > prog_done(void)
67   {
68 <        puts("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
66 <        puts("<WindowElement xmlns=\"http://windows.lbl.gov\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://windows.lbl.gov/BSDF-v1.4.xsd\">");
67 <        fputs("<!-- File produced by:", stdout);
68 <        while (ac-- > 0) {
69 <                fputc(' ', stdout);
70 <                fputs(*av++, stdout);
71 <        }
72 <        puts(" -->");
73 <        puts("<WindowElementType>System</WindowElementType>");
74 <        puts("<FileType>BSDF</FileType>");
75 <        puts("<Optical>");
76 <        puts("<Layer>");
77 <        puts("\t<Material>");
78 <        printf("\t\t<Name>%s</Name>\n", bsdf_name[0] ? bsdf_name : "Unknown");
79 <        printf("\t\t<Manufacturer>%s</Manufacturer>\n",
80 <                        bsdf_manuf[0] ? bsdf_manuf : "Unknown");
81 <        puts("\t\t<DeviceType>Other</DeviceType>");
82 <        puts("\t</Material>");
83 <        puts("\t<DataDefinition>");
84 <        printf("\t\t<IncidentDataStructure>TensorTree%c</IncidentDataStructure>\n",
85 <                        single_plane_incident ? '3' : '4');
86 <        puts("\t</DataDefinition>");
87 < }
68 >        int     n = do_prog;
69  
70 < /* Output XML data prologue to stdout */
71 < static void
72 < data_prologue()
73 < {
74 <        static const char       *bsdf_type[4] = {
94 <                                        "Reflection Front",
95 <                                        "Transmission Front",
96 <                                        "Transmission Back",
97 <                                        "Reflection Back"
98 <                                };
99 <
100 <        puts("\t<WavelengthData>");
101 <        puts("\t\t<LayerNumber>System</LayerNumber>");
102 <        puts("\t\t<Wavelength unit=\"Integral\">Visible</Wavelength>");
103 <        puts("\t\t<SourceSpectrum>CIE Illuminant D65 1nm.ssp</SourceSpectrum>");
104 <        puts("\t\t<DetectorSpectrum>ASTM E308 1931 Y.dsp</DetectorSpectrum>");
105 <        puts("\t\t<WavelengthDataBlock>");
106 <        printf("\t\t\t<WavelengthDataDirection>%s</WavelengthDataDirection>\n",
107 <                        bsdf_type[(input_orient>0)<<1 | (output_orient>0)]);
108 <        puts("\t\t\t<AngleBasis>LBNL/Shirley-Chiu</AngleBasis>");
109 <        puts("\t\t\t<ScatteringDataType>BTDF</ScatteringDataType>");
110 <        puts("\t\t\t<ScatteringData>");
70 >        if (n <= 1) return;
71 >        fputc('\r', stderr);
72 >        while (n--)
73 >                fputc(' ', stderr);
74 >        fputc('\r', stderr);
75   }
76  
113 – /* Output XML data epilogue to stdout */
114 – static void
115 – data_epilogue(void)
116 – {
117 –        puts("\t\t\t</ScatteringData>");
118 –        puts("\t\t</WavelengthDataBlock>");
119 –        puts("\t</WavelengthData>");
120 – }
121 –
122 – /* Output XML epilogue to stdout */
123 – static void
124 – xml_epilogue(void)
125 – {
126 –        puts("</Layer>");
127 –        puts("</Optical>");
128 –        puts("</WindowElement>");
129 – }
130 –
77   /* Compute absolute relative difference */
78   static double
79   abs_diff(double v1, double v0)
# Line 187 | Line 133 | eval_isotropic(char *funame)
133                          iovec[5] = output_orient *
134                                  sqrt(1. - iovec[3]*iovec[3] - iovec[4]*iovec[4]);
135                          if (funame == NULL)
136 <                            bsdf = eval_rbfrep(rbf, iovec+3) *
191 <                                                output_orient/iovec[5];
136 >                            bsdf = eval_rbfrep(rbf, iovec+3);
137                          else {
193 –                            double      ssa[3], ssvec[6], sum;
194 –                            int         ssi;
138                              if (assignD) {
139                                  varset("Dx", '=', -iovec[3]);
140                                  varset("Dy", '=', -iovec[4]);
# Line 199 | Line 142 | eval_isotropic(char *funame)
142                                  ++eclock;
143                              }
144                              bsdf = funvalue(funame, 6, iovec);
145 + #if (NSSAMP > 0)
146                              if (abs_diff(bsdf, last_bsdf) > ssamp_thresh) {
147 <                                sum = 0;        /* super-sample voxel */
148 <                                for (ssi = nssamp; ssi--; ) {
149 <                                    SDmultiSamp(ssa, 3, (ssi+frandom())/nssamp);
147 >                                int     ssi;
148 >                                double  ssa[3], ssvec[6], sum = 0;
149 >                                                /* super-sample voxel */
150 >                                for (ssi = NSSAMP; ssi--; ) {
151 >                                    SDmultiSamp(ssa, 3, (ssi+frandom()) *
152 >                                                        (1./NSSAMP));
153                                      ssvec[0] = 2.*(ix+ssa[0])/sqres - 1.;
154                                      ssvec[1] = .0;
155                                      ssvec[2] = input_orient *
# Line 213 | Line 160 | eval_isotropic(char *funame)
160                                                  sqrt(1. - ssvec[3]*ssvec[3] -
161                                                          ssvec[4]*ssvec[4]);
162                                      if (assignD) {
163 <                                        varset("Dx", '=', -iovec[3]);
164 <                                        varset("Dy", '=', -iovec[4]);
165 <                                        varset("Dz", '=', -iovec[5]);
163 >                                        varset("Dx", '=', -ssvec[3]);
164 >                                        varset("Dy", '=', -ssvec[4]);
165 >                                        varset("Dz", '=', -ssvec[5]);
166                                          ++eclock;
167                                      }
168                                      sum += funvalue(funame, 6, ssvec);
169                                  }
170 <                                bsdf = sum/nssamp;
170 >                                bsdf = sum/NSSAMP;
171                              }
172 + #endif
173                          }
174                          if (pctcull >= 0)
175                                  fwrite(&bsdf, sizeof(bsdf), 1, ofp);
# Line 298 | Line 246 | eval_anisotropic(char *funame)
246                          iovec[5] = output_orient *
247                                  sqrt(1. - iovec[3]*iovec[3] - iovec[4]*iovec[4]);
248                          if (funame == NULL)
249 <                            bsdf = eval_rbfrep(rbf, iovec+3) *
302 <                                                output_orient/iovec[5];
249 >                            bsdf = eval_rbfrep(rbf, iovec+3);
250                          else {
304 –                            double      ssa[4], ssvec[6], sum;
305 –                            int         ssi;
251                              if (assignD) {
252                                  varset("Dx", '=', -iovec[3]);
253                                  varset("Dy", '=', -iovec[4]);
# Line 310 | Line 255 | eval_anisotropic(char *funame)
255                                  ++eclock;
256                              }
257                              bsdf = funvalue(funame, 6, iovec);
258 + #if (NSSAMP > 0)
259                              if (abs_diff(bsdf, last_bsdf) > ssamp_thresh) {
260 <                                sum = 0;        /* super-sample voxel */
261 <                                for (ssi = nssamp; ssi--; ) {
262 <                                    SDmultiSamp(ssa, 4, (ssi+frandom())/nssamp);
260 >                                int     ssi;
261 >                                double  ssa[4], ssvec[6], sum = 0;
262 >                                                /* super-sample voxel */
263 >                                for (ssi = NSSAMP; ssi--; ) {
264 >                                    SDmultiSamp(ssa, 4, (ssi+frandom()) *
265 >                                                        (1./NSSAMP));
266                                      SDsquare2disk(ssvec, 1.-(ix+ssa[0])/sqres,
267                                                  1.-(iy+ssa[1])/sqres);
268 <                                    ssvec[2] = output_orient *
268 >                                    ssvec[2] = input_orient *
269                                                  sqrt(1. - ssvec[0]*ssvec[0] -
270                                                          ssvec[1]*ssvec[1]);
271                                      SDsquare2disk(ssvec+3, (ox+ssa[2])/sqres,
# Line 325 | Line 274 | eval_anisotropic(char *funame)
274                                                  sqrt(1. - ssvec[3]*ssvec[3] -
275                                                          ssvec[4]*ssvec[4]);
276                                      if (assignD) {
277 <                                        varset("Dx", '=', -iovec[3]);
278 <                                        varset("Dy", '=', -iovec[4]);
279 <                                        varset("Dz", '=', -iovec[5]);
277 >                                        varset("Dx", '=', -ssvec[3]);
278 >                                        varset("Dy", '=', -ssvec[4]);
279 >                                        varset("Dz", '=', -ssvec[5]);
280                                          ++eclock;
281                                      }
282                                      sum += funvalue(funame, 6, ssvec);
283                                  }
284 <                                bsdf = sum/nssamp;
284 >                                bsdf = sum/NSSAMP;
285                              }
286 + #endif
287                          }
288                          if (pctcull >= 0)
289                                  fwrite(&bsdf, sizeof(bsdf), 1, ofp);

Diff Legend

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