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

Comparing ray/src/cv/pabopto2xml.c (file contents):
Revision 2.4 by greg, Sat Aug 25 02:53:06 2012 UTC vs.
Revision 2.5 by greg, Sat Aug 25 22:39:03 2012 UTC

# Line 26 | Line 26 | static const char RCSid[] = "$Id$";
26   #define ANG2R(r)        (int)((r)*((1<<16)/M_PI))
27  
28   typedef struct {
29 <        float           vsum;           /* BSDF sum */
29 >        float           vsum;           /* DSF sum */
30          unsigned short  nval;           /* number of values in sum */
31          unsigned short  crad;           /* radius (coded angle) */
32   } GRIDVAL;                      /* grid value */
33  
34   typedef struct {
35 <        float           bsdf;           /* lobe value at peak */
35 >        float           peak;           /* lobe value at peak */
36          unsigned short  crad;           /* radius (coded angle) */
37          unsigned char   gx, gy;         /* grid position */
38   } RBFVAL;                       /* radial basis function value */
# Line 42 | Line 42 | typedef struct s_rbflist {
42          FVECT                   invec;          /* incident vector direction */
43          int                     nrbf;           /* number of RBFs */
44          RBFVAL                  rbfa[1];        /* RBF array (extends struct) */
45 < } RBFLIST;                      /* RBF representation of BSDF @ 1 incidence */
45 > } RBFLIST;                      /* RBF representation of DSF @ 1 incidence */
46  
47                                  /* our loaded grid for this incident angle */
48   static double   theta_in_deg, phi_in_deg;
49 < static GRIDVAL  bsdf_grid[GRIDRES][GRIDRES];
49 > static GRIDVAL  dsf_grid[GRIDRES][GRIDRES];
50  
51 <                                /* processed incident BSDF measurements */
52 < static RBFLIST  *bsdf_list = NULL;
51 >                                /* processed incident DSF measurements */
52 > static RBFLIST  *dsf_list = NULL;
53  
54   /* Compute outgoing vector from grid position */
55   static void
# Line 80 | Line 80 | pos_from_vec(int pos[2], const FVECT vec)
80          pos[1] = (int)(sq[1]*GRIDRES);
81   }
82  
83 < /* Evaluate RBF for BSDF at the given normalized outgoing direction */
83 > /* Evaluate RBF for DSF at the given normalized outgoing direction */
84   static double
85   eval_rbfrep(const RBFLIST *rp, const FVECT outvec)
86   {
# Line 96 | Line 96 | eval_rbfrep(const RBFLIST *rp, const FVECT outvec)
96                  sig2 = R2ANG(rbfp->crad);
97                  sig2 = (DOT(odir,outvec) - 1.) / (sig2*sig2);
98                  if (sig2 > -19.)
99 <                        res += rbfp->bsdf * exp(sig2);
99 >                        res += rbfp->peak * exp(sig2);
100          }
101          return(res);
102   }
# Line 113 | Line 113 | make_rbfrep(void)
113          nn = 0;                 /* count selected bins */
114          for (i = 0; i < GRIDRES; i++)
115              for (j = 0; j < GRIDRES; j++)
116 <                nn += (bsdf_grid[i][j].nval > 0);
116 >                nn += (dsf_grid[i][j].nval > 0);
117                                  /* allocate RBF array */
118          newnode = (RBFLIST *)malloc(sizeof(RBFLIST) + sizeof(RBFVAL)*(nn-1));
119          if (newnode == NULL) {
# Line 129 | Line 129 | make_rbfrep(void)
129          nn = 0;                 /* fill RBF array */
130          for (i = 0; i < GRIDRES; i++)
131              for (j = 0; j < GRIDRES; j++)
132 <                if (bsdf_grid[i][j].nval) {
133 <                        newnode->rbfa[nn].bsdf =
134 <                                        bsdf_grid[i][j].vsum /=
135 <                                                (double)bsdf_grid[i][j].nval;
136 <                        bsdf_grid[i][j].nval = 1;
137 <                        newnode->rbfa[nn].crad = RSCA*bsdf_grid[i][j].crad + .5;
132 >                if (dsf_grid[i][j].nval) {
133 >                        newnode->rbfa[nn].peak =
134 >                                        dsf_grid[i][j].vsum /=
135 >                                                (double)dsf_grid[i][j].nval;
136 >                        dsf_grid[i][j].nval = 1;
137 >                        newnode->rbfa[nn].crad = RSCA*dsf_grid[i][j].crad + .5;
138                          newnode->rbfa[nn].gx = i;
139                          newnode->rbfa[nn].gy = j;
140                          ++nn;
# Line 145 | Line 145 | make_rbfrep(void)
145                  nn = 0;
146                  for (i = 0; i < GRIDRES; i++)
147                      for (j = 0; j < GRIDRES; j++)
148 <                        if (bsdf_grid[i][j].nval) {
148 >                        if (dsf_grid[i][j].nval) {
149                                  FVECT   odir;
150                                  /* double       corr; */
151                                  vec_from_pos(odir, i, j);
152 <                                newnode->rbfa[nn++].bsdf *= /* corr = */
153 <                                        bsdf_grid[i][j].vsum /
152 >                                newnode->rbfa[nn++].peak *= /* corr = */
153 >                                        dsf_grid[i][j].vsum /
154                                                  eval_rbfrep(newnode, odir);
155                                  /*
156                                  dsum += corr - 1.;
# Line 163 | Line 163 | make_rbfrep(void)
163                                          100.*sqrt(dsum2/(double)nn));
164                  */
165          }
166 <        newnode->next = bsdf_list;
167 <        return(bsdf_list = newnode);
166 >        newnode->next = dsf_list;
167 >        return(dsf_list = newnode);
168   }
169  
170   /* Load a set of measurements corresponding to a particular incident angle */
# Line 182 | Line 182 | load_bsdf_meas(const char *fname)
182                  fputs(": cannot open\n", stderr);
183                  return(0);
184          }
185 <        memset(bsdf_grid, 0, sizeof(bsdf_grid));
185 >        memset(dsf_grid, 0, sizeof(dsf_grid));
186                                  /* read header information */
187          while ((c = getc(fp)) == '#' || c == EOF) {
188                  if (fgets(buf, sizeof(buf), fp) == NULL) {
# Line 223 | Line 223 | load_bsdf_meas(const char *fname)
223                  ovec[1] = sin(M_PI/180.*phi_out) * ovec[2];
224                  ovec[2] = sqrt(1. - ovec[2]*ovec[2]);
225  
226 <                if (inp_is_DSF)
227 <                        val /= ovec[2]; /* convert from DSF to BSDF */
226 >                if (!inp_is_DSF)
227 >                        val *= ovec[2]; /* convert from BSDF to DSF */
228  
229                  pos_from_vec(pos, ovec);
230  
231 <                bsdf_grid[pos[0]][pos[1]].vsum += val;
232 <                bsdf_grid[pos[0]][pos[1]].nval++;
231 >                dsf_grid[pos[0]][pos[1]].vsum += val;
232 >                dsf_grid[pos[0]][pos[1]].nval++;
233          }
234          n = 0;
235          while ((c = getc(fp)) != EOF)
# Line 257 | Line 257 | compute_radii(void)
257          for (i = 0; i < GRIDRES; i++)
258              for (jn = 0; jn < GRIDRES; jn++) {
259                  j = (i&1) ? jn : GRIDRES-1-jn;
260 <                if (bsdf_grid[i][j].nval)       /* find empty grid pos. */
260 >                if (dsf_grid[i][j].nval)        /* find empty grid pos. */
261                          continue;
262                  vec_from_pos(ovec0, i, j);
263                  inear = jnear = -1;             /* find nearest non-empty */
# Line 268 | Line 268 | compute_radii(void)
268                      for (jj = j-r; jj <= j+r; jj++) {
269                          if (jj < 0) continue;
270                          if (jj >= GRIDRES) break;
271 <                        if (!bsdf_grid[ii][jj].nval)
271 >                        if (!dsf_grid[ii][jj].nval)
272                                  continue;
273                          vec_from_pos(ovec1, ii, jj);
274                          ang2 = 2. - 2.*DOT(ovec0,ovec1);
# Line 284 | Line 284 | compute_radii(void)
284                  }
285                  ang2 = sqrt(lastang2);
286                  r = ANG2R(ang2);                /* record if > previous */
287 <                if (r > bsdf_grid[inear][jnear].crad)
288 <                        bsdf_grid[inear][jnear].crad = r;
287 >                if (r > dsf_grid[inear][jnear].crad)
288 >                        dsf_grid[inear][jnear].crad = r;
289                                                  /* next search radius */
290                  r = ang2*(2.*GRIDRES/M_PI) + 1;
291              }
# Line 294 | Line 294 | compute_radii(void)
294          memset(fill_cnt, 0, sizeof(fill_cnt));
295          for (i = 0; i < GRIDRES; i++)
296              for (j = 0; j < GRIDRES; j++) {
297 <                if (!bsdf_grid[i][j].crad)
297 >                if (!dsf_grid[i][j].crad)
298                          continue;               /* missing distance */
299 <                r = R2ANG(bsdf_grid[i][j].crad)*(2.*RSCA*GRIDRES/M_PI);
299 >                r = R2ANG(dsf_grid[i][j].crad)*(2.*RSCA*GRIDRES/M_PI);
300                  for (ii = i-r; ii <= i+r; ii++) {
301                      if (ii < 0) continue;
302                      if (ii >= GRIDRES) break;
# Line 305 | Line 305 | compute_radii(void)
305                          if (jj >= GRIDRES) break;
306                          if ((ii-i)*(ii-i) + (jj-j)*(jj-j) > r*r)
307                                  continue;
308 <                        fill_grid[ii][jj] += bsdf_grid[i][j].crad;
308 >                        fill_grid[ii][jj] += dsf_grid[i][j].crad;
309                          fill_cnt[ii][jj]++;
310                      }
311                  }
# Line 314 | Line 314 | compute_radii(void)
314          for (i = 0; i < GRIDRES; i++)
315              for (j = 0; j < GRIDRES; j++)
316                  if (fill_cnt[i][j])
317 <                        bsdf_grid[i][j].crad = fill_grid[i][j]/fill_cnt[i][j];
317 >                        dsf_grid[i][j].crad = fill_grid[i][j]/fill_cnt[i][j];
318   }
319  
320   /* Cull points for more uniform distribution */
# Line 327 | Line 327 | cull_values(void)
327                                                  /* simple greedy algorithm */
328          for (i = 0; i < GRIDRES; i++)
329              for (j = 0; j < GRIDRES; j++) {
330 <                if (!bsdf_grid[i][j].nval)
330 >                if (!dsf_grid[i][j].nval)
331                          continue;
332 <                if (!bsdf_grid[i][j].crad)
332 >                if (!dsf_grid[i][j].crad)
333                          continue;               /* shouldn't happen */
334                  vec_from_pos(ovec0, i, j);
335 <                maxang = 2.*R2ANG(bsdf_grid[i][j].crad);
335 >                maxang = 2.*R2ANG(dsf_grid[i][j].crad);
336                  if (maxang > ovec0[2])          /* clamp near horizon */
337                          maxang = ovec0[2];
338                  r = maxang*(2.*GRIDRES/M_PI) + 1;
# Line 343 | Line 343 | cull_values(void)
343                      for (jj = j-r; jj <= j+r; jj++) {
344                          if (jj < 0) continue;
345                          if (jj >= GRIDRES) break;
346 <                        if (!bsdf_grid[ii][jj].nval)
346 >                        if (!dsf_grid[ii][jj].nval)
347                                  continue;
348                          if ((ii == i) & (jj == j))
349                                  continue;       /* don't get self-absorbed */
# Line 351 | Line 351 | cull_values(void)
351                          if (2. - 2.*DOT(ovec0,ovec1) >= maxang2)
352                                  continue;
353                                                  /* absorb sum */
354 <                        bsdf_grid[i][j].vsum += bsdf_grid[ii][jj].vsum;
355 <                        bsdf_grid[i][j].nval += bsdf_grid[ii][jj].nval;
354 >                        dsf_grid[i][j].vsum += dsf_grid[ii][jj].vsum;
355 >                        dsf_grid[i][j].nval += dsf_grid[ii][jj].nval;
356                                                  /* keep value, though */
357 <                        bsdf_grid[ii][jj].vsum /= (double)bsdf_grid[ii][jj].nval;
358 <                        bsdf_grid[ii][jj].nval = 0;
357 >                        dsf_grid[ii][jj].vsum /= (double)dsf_grid[ii][jj].nval;
358 >                        dsf_grid[ii][jj].nval = 0;
359                      }
360                  }
361              }
# Line 389 | Line 389 | main(int argc, char *argv[])
389          n = 0;
390          for (i = 0; i < GRIDRES; i++)
391              for (j = 0; j < GRIDRES; j++)
392 <                if (bsdf_grid[i][j].vsum > .0f) {
393 <                        bsdf = bsdf_grid[i][j].vsum;
392 >                if (dsf_grid[i][j].vsum > .0f) {
393                          vec_from_pos(dir, i, j);
394 <                        if (bsdf_grid[i][j].nval) {
394 >                        bsdf = dsf_grid[i][j].vsum / dir[2];
395 >                        if (dsf_grid[i][j].nval) {
396                                  printf("pink cone c%04d\n0\n0\n8\n", ++n);
397                                  printf("\t%.6g %.6g %.6g\n",
398                                          dir[0]*bsdf, dir[1]*bsdf, dir[2]*bsdf);
# Line 410 | Line 410 | main(int argc, char *argv[])
410                                                  /* output continuous surface */
411          puts("void trans tgreen\n0\n0\n7 .7 1 .7 .04 .04 .9 .9\n");
412          fflush(stdout);
413 <        sprintf(buf, "gensurf tgreen bsdf - - - %d %d", GRIDRES, GRIDRES);
413 >        sprintf(buf, "gensurf tgreen bsdf - - - %d %d", GRIDRES-1, GRIDRES-1);
414          pfp = popen(buf, "w");
415          if (pfp == NULL) {
416                  fputs(buf, stderr);
# Line 420 | Line 420 | main(int argc, char *argv[])
420          for (i = 0; i < GRIDRES; i++)
421              for (j = 0; j < GRIDRES; j++) {
422                  vec_from_pos(dir, i, j);
423 <                bsdf = eval_rbfrep(bsdf_list, dir);
423 >                bsdf = eval_rbfrep(dsf_list, dir) / dir[2];
424                  fprintf(pfp, "%.8e %.8e %.8e\n",
425                                  dir[0]*bsdf, dir[1]*bsdf, dir[2]*bsdf);
426              }

Diff Legend

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