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

Comparing src/cv/bsdf2ttree.c (file contents):
Revision 2.11 by greg, Fri Mar 22 02:15:06 2013 UTC vs.
Revision 2.21 by greg, Sat Nov 9 05:47:49 2013 UTC

# Line 20 | Line 20 | char                   *progname;
20   double                  pctcull = 90.;
21                                  /* sampling order */
22   int                     samp_order = 6;
23 +                                /* super-sampling threshold */
24 + const double            ssamp_thresh = 0.35;
25 +                                /* number of super-samples */
26 + const int               nssamp = 100;
27 +                                /* limit on number of RBF lobes */
28 + static int              lobe_lim = 15000;
29  
30   /* Output XML prologue to stdout */
31   static void
# Line 38 | Line 44 | xml_prologue(int ac, char *av[])
44          puts("<Optical>");
45          puts("<Layer>");
46          puts("\t<Material>");
47 <        puts("\t\t<Name>Name</Name>");
48 <        puts("\t\t<Manufacturer>Manufacturer</Manufacturer>");
47 >        printf("\t\t<Name>%s</Name>\n", bsdf_name[0] ? bsdf_name : "Unknown");
48 >        printf("\t\t<Manufacturer>%s</Manufacturer>\n",
49 >                        bsdf_manuf[0] ? bsdf_manuf : "Unknown");
50          puts("\t\t<DeviceType>Other</DeviceType>");
51          puts("\t</Material>");
52          puts("\t<DataDefinition>");
# Line 90 | Line 97 | xml_epilogue(void)
97          puts("</WindowElement>");
98   }
99  
100 + /* Compute absolute relative difference */
101 + static double
102 + abs_diff(double v1, double v0)
103 + {
104 +        if ((v0 < 0) | (v1 < 0))
105 +                return(.0);
106 +        v1 = (v1-v0)*2./(v0+v1+.0001);
107 +        if (v1 < 0)
108 +                return(-v1);
109 +        return(v1);
110 + }
111 +
112   /* Interpolate and output isotropic BSDF data */
113   static void
114   eval_isotropic(char *funame)
115   {
116          const int       sqres = 1<<samp_order;
117          FILE            *ofp = NULL;
118 +        int             assignD = 0;
119          char            cmd[128];
120          int             ix, ox, oy;
121          double          iovec[6];
122          float           bsdf;
123 < #if DEBUG
104 <        fprintf(stderr, "Writing isotropic order %d ", samp_order);
105 <        if (pctcull >= 0) fprintf(stderr, "data with %.1f%% culling\n", pctcull);
106 <        else fputs("raw data\n", stderr);
107 < #endif
123 >
124          data_prologue();                        /* begin output */
125          if (pctcull >= 0) {
126 <                sprintf(cmd, "rttree_reduce -h -a -ff -r 3 -t %f -g %d",
126 >                sprintf(cmd, "rttree_reduce -a -h -ff -r 3 -t %f -g %d",
127                                  pctcull, samp_order);
128                  fflush(stdout);
129                  ofp = popen(cmd, "w");
# Line 119 | Line 135 | eval_isotropic(char *funame)
135                  SET_FILE_BINARY(ofp);
136          } else
137                  fputs("{\n", stdout);
138 +                                                /* need to assign Dx, Dy, Dz? */
139 +        if (funame != NULL)
140 +                assignD = (fundefined(funame) < 6);
141                                                  /* run through directions */
142          for (ix = 0; ix < sqres/2; ix++) {
143                  RBFNODE *rbf = NULL;
144 <                iovec[0] = (ix+.5)/sqres - 1.;
144 >                iovec[0] = 2.*(ix+.5)/sqres - 1.;
145                  iovec[1] = .0;
146                  iovec[2] = input_orient * sqrt(1. - iovec[0]*iovec[0]);
147                  if (funame == NULL)
148 <                        rbf = advect_rbf(iovec);
149 <                for (ox = 0; ox < sqres; ox++)
148 >                        rbf = advect_rbf(iovec, lobe_lim);
149 >                for (ox = 0; ox < sqres; ox++) {
150 >                    float       last_bsdf = -1;
151                      for (oy = 0; oy < sqres; oy++) {
152                          SDsquare2disk(iovec+3, (ox+.5)/sqres, (oy+.5)/sqres);
153                          iovec[5] = output_orient *
154                                  sqrt(1. - iovec[3]*iovec[3] - iovec[4]*iovec[4]);
155                          if (funame == NULL)
156 <                                bsdf = eval_rbfrep(rbf, iovec+3) *
156 >                            bsdf = eval_rbfrep(rbf, iovec+3) *
157                                                  output_orient/iovec[5];
158 <                        else
159 <                                bsdf = funvalue(funame, 6, iovec);
158 >                        else {
159 >                            double      ssa[3], ssvec[6], sum;
160 >                            int         ssi;
161 >                            if (assignD) {
162 >                                varset("Dx", '=', -iovec[3]);
163 >                                varset("Dy", '=', -iovec[4]);
164 >                                varset("Dz", '=', -iovec[5]);
165 >                                ++eclock;
166 >                            }
167 >                            bsdf = funvalue(funame, 6, iovec);
168 >                            if (abs_diff(bsdf, last_bsdf) > ssamp_thresh) {
169 >                                sum = 0;        /* super-sample voxel */
170 >                                for (ssi = nssamp; ssi--; ) {
171 >                                    SDmultiSamp(ssa, 3, (ssi+drand48())/nssamp);
172 >                                    ssvec[0] = 2.*(ix+ssa[0])/sqres - 1.;
173 >                                    ssvec[1] = .0;
174 >                                    ssvec[2] = input_orient *
175 >                                                sqrt(1. - ssvec[0]*ssvec[0]);
176 >                                    SDsquare2disk(ssvec+3, (ox+ssa[1])/sqres,
177 >                                                (oy+ssa[2])/sqres);
178 >                                    ssvec[5] = output_orient *
179 >                                                sqrt(1. - ssvec[3]*ssvec[3] -
180 >                                                        ssvec[4]*ssvec[4]);
181 >                                    if (assignD) {
182 >                                        varset("Dx", '=', -iovec[3]);
183 >                                        varset("Dy", '=', -iovec[4]);
184 >                                        varset("Dz", '=', -iovec[5]);
185 >                                        ++eclock;
186 >                                    }
187 >                                    sum += funvalue(funame, 6, ssvec);
188 >                                }
189 >                                bsdf = sum/nssamp;
190 >                            }
191 >                        }
192                          if (pctcull >= 0)
193                                  fwrite(&bsdf, sizeof(bsdf), 1, ofp);
194                          else
195                                  printf("\t%.3e\n", bsdf);
196 +                        last_bsdf = bsdf;
197                      }
198 +                }
199                  if (rbf != NULL)
200                          free(rbf);
201          }
# Line 165 | Line 219 | eval_anisotropic(char *funame)
219   {
220          const int       sqres = 1<<samp_order;
221          FILE            *ofp = NULL;
222 +        int             assignD = 0;
223          char            cmd[128];
224          int             ix, iy, ox, oy;
225          double          iovec[6];
226          float           bsdf;
227 < #if DEBUG
173 <        fprintf(stderr, "Writing anisotropic order %d ", samp_order);
174 <        if (pctcull >= 0) fprintf(stderr, "data with %.1f%% culling\n", pctcull);
175 <        else fputs("raw data\n", stderr);
176 < #endif
227 >
228          data_prologue();                        /* begin output */
229          if (pctcull >= 0) {
230 <                sprintf(cmd, "rttree_reduce -h -a -ff -r 4 -t %f -g %d",
230 >                sprintf(cmd, "rttree_reduce%s -h -ff -r 4 -t %f -g %d",
231 >                                (input_orient>0 ^ output_orient>0) ? "" : " -a",
232                                  pctcull, samp_order);
233                  fflush(stdout);
234                  ofp = popen(cmd, "w");
# Line 187 | Line 239 | eval_anisotropic(char *funame)
239                  }
240          } else
241                  fputs("{\n", stdout);
242 +                                                /* need to assign Dx, Dy, Dz? */
243 +        if (funame != NULL)
244 +                assignD = (fundefined(funame) < 6);
245                                                  /* run through directions */
246          for (ix = 0; ix < sqres; ix++)
247              for (iy = 0; iy < sqres; iy++) {
248                  RBFNODE *rbf = NULL;            /* Klems reversal */
249 <                SDsquare2disk(iovec, (ix+.5)/sqres, (iy+.5)/sqres);
195 <                iovec[0] = -iovec[0]; iovec[1] = -iovec[1];
249 >                SDsquare2disk(iovec, 1.-(ix+.5)/sqres, 1.-(iy+.5)/sqres);
250                  iovec[2] = input_orient *
251                                  sqrt(1. - iovec[0]*iovec[0] - iovec[1]*iovec[1]);
252                  if (funame == NULL)
253 <                        rbf = advect_rbf(iovec);
254 <                for (ox = 0; ox < sqres; ox++)
253 >                        rbf = advect_rbf(iovec, lobe_lim);
254 >                for (ox = 0; ox < sqres; ox++) {
255 >                    float       last_bsdf = -1;
256                      for (oy = 0; oy < sqres; oy++) {
257                          SDsquare2disk(iovec+3, (ox+.5)/sqres, (oy+.5)/sqres);
258                          iovec[5] = output_orient *
259                                  sqrt(1. - iovec[3]*iovec[3] - iovec[4]*iovec[4]);
260                          if (funame == NULL)
261 <                                bsdf = eval_rbfrep(rbf, iovec+3) *
261 >                            bsdf = eval_rbfrep(rbf, iovec+3) *
262                                                  output_orient/iovec[5];
263 <                        else
264 <                                bsdf = funvalue(funame, 6, iovec);
263 >                        else {
264 >                            double      ssa[4], ssvec[6], sum;
265 >                            int         ssi;
266 >                            if (assignD) {
267 >                                varset("Dx", '=', -iovec[3]);
268 >                                varset("Dy", '=', -iovec[4]);
269 >                                varset("Dz", '=', -iovec[5]);
270 >                                ++eclock;
271 >                            }
272 >                            bsdf = funvalue(funame, 6, iovec);
273 >                            if (abs_diff(bsdf, last_bsdf) > ssamp_thresh) {
274 >                                sum = 0;        /* super-sample voxel */
275 >                                for (ssi = nssamp; ssi--; ) {
276 >                                    SDmultiSamp(ssa, 4, (ssi+drand48())/nssamp);
277 >                                    SDsquare2disk(ssvec, 1.-(ix+ssa[0])/sqres,
278 >                                                1.-(iy+ssa[1])/sqres);
279 >                                    ssvec[2] = output_orient *
280 >                                                sqrt(1. - ssvec[0]*ssvec[0] -
281 >                                                        ssvec[1]*ssvec[1]);
282 >                                    SDsquare2disk(ssvec+3, (ox+ssa[2])/sqres,
283 >                                                (oy+ssa[3])/sqres);
284 >                                    ssvec[5] = output_orient *
285 >                                                sqrt(1. - ssvec[3]*ssvec[3] -
286 >                                                        ssvec[4]*ssvec[4]);
287 >                                    if (assignD) {
288 >                                        varset("Dx", '=', -iovec[3]);
289 >                                        varset("Dy", '=', -iovec[4]);
290 >                                        varset("Dz", '=', -iovec[5]);
291 >                                        ++eclock;
292 >                                    }
293 >                                    sum += funvalue(funame, 6, ssvec);
294 >                                }
295 >                                bsdf = sum/nssamp;
296 >                            }
297 >                        }
298                          if (pctcull >= 0)
299                                  fwrite(&bsdf, sizeof(bsdf), 1, ofp);
300                          else
301                                  printf("\t%.3e\n", bsdf);
302 +                        last_bsdf = bsdf;
303                      }
304 +                }
305                  if (rbf != NULL)
306                          free(rbf);
307              }
# Line 255 | Line 345 | main(int argc, char *argv[])
345                  case 't':
346                          switch (argv[i][2]) {
347                          case '3':
348 <                                single_plane_incident = 0;
348 >                                single_plane_incident = 1;
349                                  break;
350                          case '4':
351 <                                single_plane_incident = 1;
351 >                                single_plane_incident = 0;
352                                  break;
353                          case '\0':
354                                  pctcull = atof(argv[++i]);
# Line 270 | Line 360 | main(int argc, char *argv[])
360                  case 'g':
361                          samp_order = atoi(argv[++i]);
362                          break;
363 +                case 'l':
364 +                        lobe_lim = atoi(argv[++i]);
365 +                        break;
366                  default:
367                          goto userr;
368                  }
369          if (single_plane_incident >= 0) {       /* function-based BSDF? */
370                  void    (*evf)(char *s) = single_plane_incident ?
371                                  &eval_isotropic : &eval_anisotropic;
372 <                if (i != argc-1 || fundefined(argv[i]) != 6)
372 >                if (i != argc-1 || fundefined(argv[i]) < 3) {
373 >                        fprintf(stderr,
374 >        "%s: need single function with 6 arguments: bsdf(ix,iy,iz,ox,oy,oz)\n",
375 >                                        progname);
376 >                        fprintf(stderr, "\tor 3 arguments using Dx,Dy,Dz: bsdf(ix,iy,iz)\n",
377 >                                        progname);
378                          goto userr;
379 +                }
380 +                ++eclock;
381                  xml_prologue(argc, argv);       /* start XML output */
382                  if (dofwd) {
383                          input_orient = -1;
# Line 297 | Line 397 | main(int argc, char *argv[])
397                  return(0);
398          }
399          if (i < argc) {                         /* open input files if given */
400 <                xml_prologue(argc, argv);       /* start XML output */
400 >                int     nbsdf = 0;
401                  for ( ; i < argc; i++) {        /* interpolate each component */
402                          FILE    *fpin = fopen(argv[i], "rb");
403                          if (fpin == NULL) {
# Line 308 | Line 408 | main(int argc, char *argv[])
408                          if (!load_bsdf_rep(fpin))
409                                  return(1);
410                          fclose(fpin);
411 +                        if (!nbsdf++)           /* start XML on first dist. */
412 +                                xml_prologue(argc, argv);
413                          if (single_plane_incident)
414                                  eval_isotropic(NULL);
415                          else
# Line 328 | Line 430 | main(int argc, char *argv[])
430          return(0);
431   userr:
432          fprintf(stderr,
433 <        "Usage: %s [-g Nlog2][-t pctcull] [bsdf.sir ..] > bsdf.xml\n",
433 >        "Usage: %s [-g Nlog2][-t pctcull][-l maxlobes] [bsdf.sir ..] > bsdf.xml\n",
434                                  progname);
435          fprintf(stderr,
436          "   or: %s -t{3|4} [-g Nlog2][-t pctcull][{+|-}for[ward]][{+|-}b[ackward]][-e expr][-f file] bsdf_func > bsdf.xml\n",

Diff Legend

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