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

Comparing ray/src/cv/bsdfmesh.c (file contents):
Revision 2.19 by greg, Sat Mar 8 18:16:48 2014 UTC vs.
Revision 2.40 by greg, Tue Apr 23 14:30:36 2019 UTC

# Line 7 | Line 7 | static const char RCSid[] = "$Id$";
7   *      G. Ward
8   */
9  
10 < #ifndef _WIN32
10 > #if !defined(_WIN32) && !defined(_WIN64)
11   #include <unistd.h>
12   #include <sys/wait.h>
13   #include <sys/mman.h>
# Line 20 | Line 20 | static const char RCSid[] = "$Id$";
20   #include "bsdfrep.h"
21  
22   #ifndef NEIGH_FACT2
23 < #define NEIGH_FACT2     0.2     /* empirical neighborhood distance weight */
23 > #define NEIGH_FACT2     0.1     /* empirical neighborhood distance weight */
24   #endif
25                                  /* number of processes to run */
26   int                     nprocs = 1;
27                                  /* number of children (-1 in child) */
28   static int              nchild = 0;
29  
30 < typedef struct {
31 <        int             nrows, ncols;   /* array size (matches migration) */
32 <        float           *price;         /* migration prices */
33 <        short           *sord;          /* sort for each row, low to high */
34 <        float           *prow;          /* current price row */
35 < } PRICEMAT;                     /* sorted pricing matrix */
30 > /* Compute average DSF value at the given radius from central vector */
31 > static double
32 > eval_DSFsurround(const RBFNODE *rbf, const FVECT outvec, const double rad)
33 > {
34 >        const int       ninc = 12;
35 >        const double    phinc = 2.*M_PI/ninc;
36 >        double          sum = 0;
37 >        int             n = 0;
38 >        FVECT           tvec;
39 >        int             i;
40 >                                                /* compute initial vector */
41 >        if (output_orient*outvec[2] >= 1.-FTINY) {
42 >                tvec[0] = tvec[2] = 0;
43 >                tvec[1] = 1;
44 >        } else {
45 >                tvec[0] = tvec[1] = 0;
46 >                tvec[2] = 1;
47 >        }
48 >        geodesic(tvec, outvec, tvec, rad, GEOD_RAD);
49 >                                                /* average surrounding DSF */
50 >        for (i = 0; i < ninc; i++) {
51 >                if (i) spinvector(tvec, tvec, outvec, phinc);
52 >                if (tvec[2] > 0 ^ output_orient > 0)
53 >                        continue;
54 >                sum += eval_rbfrep(rbf, tvec) * COSF(tvec[2]);
55 >                ++n;
56 >        }
57 >        if (n < 2)                              /* should never happen! */
58 >                return(sum);
59 >        return(sum/(double)n);
60 > }
61  
62 < #define pricerow(p,i)   ((p)->price + (i)*(p)->ncols)
63 < #define psortrow(p,i)   ((p)->sord + (i)*(p)->ncols)
62 > /* Estimate single-lobe radius for DSF at the given outgoing angle */
63 > static double
64 > est_DSFrad(const RBFNODE *rbf, const FVECT outvec)
65 > {
66 >        const double    rad_epsilon = 0.01;
67 >        const double    DSFtarget = 0.60653066 * eval_rbfrep(rbf,outvec) *
68 >                                                        COSF(outvec[2]);
69 >        double          inside_rad = rad_epsilon;
70 >        double          outside_rad = 0.5;
71 >        double          DSFinside = eval_DSFsurround(rbf, outvec, inside_rad);
72 >        double          DSFoutside = eval_DSFsurround(rbf, outvec, outside_rad);
73 > #define interp_rad      inside_rad + (outside_rad-inside_rad) * \
74 >                                (DSFtarget-DSFinside) / (DSFoutside-DSFinside)
75 >                                                /* Newton's method (sort of) */
76 >        do {
77 >                double  test_rad = interp_rad;
78 >                double  DSFtest;
79 >                if ((test_rad >= outside_rad) | (test_rad <= inside_rad))
80 >                        test_rad = .5*(inside_rad + outside_rad);
81 >                DSFtest = eval_DSFsurround(rbf, outvec, test_rad);
82 >                if (DSFtest > DSFtarget) {
83 >                        inside_rad = test_rad;
84 >                        DSFinside = DSFtest;
85 >                } else {
86 >                        outside_rad = test_rad;
87 >                        DSFoutside = DSFtest;
88 >                }
89 >        } while (outside_rad-inside_rad > rad_epsilon);
90  
91 +        return(.5*(inside_rad + outside_rad));
92 + #undef interp_rad
93 + }
94 +
95 + static int
96 + dbl_cmp(const void *p1, const void *p2)
97 + {
98 +        double  d1 = *(const double *)p1;
99 +        double  d2 = *(const double *)p2;
100 +
101 +        if (d1 > d2) return(1);
102 +        if (d1 < d2) return(-1);
103 +        return(0);
104 + }
105 +
106 + /* Conservative estimate of average BSDF value from current DSF's */
107 + static void
108 + comp_bsdf_spec(void)
109 + {
110 +        double          vmod_sum = 0;
111 +        double          rad_sum = 0;
112 +        int             n = 0;
113 +        double          *cost_list = NULL;
114 +        double          max_cost = 1.;
115 +        RBFNODE         *rbf;
116 +        FVECT           sdv;
117 +                                                /* sort by incident altitude */
118 +        for (rbf = dsf_list; rbf != NULL; rbf = rbf->next)
119 +                n++;
120 +        if (n >= 10)
121 +                cost_list = (double *)malloc(sizeof(double)*n);
122 +        if (cost_list == NULL) {
123 +                bsdf_spec_val = 0;
124 +                bsdf_spec_rad = 0;
125 +                return;
126 +        }
127 +        n = 0;
128 +        for (rbf = dsf_list; rbf != NULL; rbf = rbf->next)
129 +                cost_list[n++] = rbf->invec[2]*input_orient;
130 +        qsort(cost_list, n, sizeof(double), dbl_cmp);
131 +        max_cost = cost_list[(n+3)/4];          /* accept 25% nearest grazing */
132 +        free(cost_list);
133 +        n = 0;
134 +        for (rbf = dsf_list; rbf != NULL; rbf = rbf->next) {
135 +                double  this_rad, cosfact, vest;
136 +                if (rbf->invec[2]*input_orient > max_cost)
137 +                        continue;
138 +                sdv[0] = -rbf->invec[0];
139 +                sdv[1] = -rbf->invec[1];
140 +                sdv[2] = rbf->invec[2]*(2*(input_orient==output_orient) - 1);
141 +                cosfact = COSF(sdv[2]);
142 +                this_rad = est_DSFrad(rbf, sdv);
143 +                vest = eval_rbfrep(rbf, sdv) * cosfact *
144 +                                (2.*M_PI) * this_rad*this_rad;
145 +                if (vest > rbf->vtotal)         /* don't over-estimate energy */
146 +                        vest = rbf->vtotal;
147 +                vmod_sum += vest / cosfact;     /* remove cosine factor */
148 +                rad_sum += this_rad;
149 +                ++n;
150 +        }
151 +        bsdf_spec_rad = rad_sum/(double)n;
152 +        bsdf_spec_val = vmod_sum/(2.*M_PI*n*bsdf_spec_rad*bsdf_spec_rad);
153 + }
154 +
155   /* Create a new migration holder (sharing memory for multiprocessing) */
156   static MIGRATION *
157   new_migration(RBFNODE *from_rbf, RBFNODE *to_rbf)
# Line 44 | Line 159 | new_migration(RBFNODE *from_rbf, RBFNODE *to_rbf)
159          size_t          memlen = sizeof(MIGRATION) +
160                                  sizeof(float)*(from_rbf->nrbf*to_rbf->nrbf - 1);
161          MIGRATION       *newmig;
162 < #ifdef _WIN32
162 > #if defined(_WIN32) || defined(_WIN64)
163          if (nprocs > 1)
164                  fprintf(stderr, "%s: warning - multiprocessing not supported\n",
165                                  progname);
# Line 75 | Line 190 | new_migration(RBFNODE *from_rbf, RBFNODE *to_rbf)
190          return(mig_list = newmig);
191   }
192  
193 < #ifdef _WIN32
193 > #if defined(_WIN32) || defined(_WIN64)
194   #define await_children(n)       (void)(n)
195   #define run_subprocess()        0
196   #define end_subprocess()        (void)0
# Line 150 | Line 265 | compute_nDSFs(const RBFNODE *rbf0, const RBFNODE *rbf1
265  
266          for (x = GRIDRES; x--; )
267              for (y = GRIDRES; y--; ) {
268 <                ovec_from_pos(dv, x, y);
269 <                dsf_grid[x][y].val[0] = nf0 * eval_rbfrep(rbf0, dv);
270 <                dsf_grid[x][y].val[1] = nf1 * eval_rbfrep(rbf1, dv);
268 >                ovec_from_pos(dv, x, y);        /* cube root (brightness) */
269 >                dsf_grid[x][y].val[0] = pow(nf0*eval_rbfrep(rbf0, dv), .3333);
270 >                dsf_grid[x][y].val[1] = pow(nf1*eval_rbfrep(rbf1, dv), .3333);
271              }
272   }      
273  
# Line 165 | Line 280 | neighborhood_dist2(int x0, int y0, int x1, int y1)
280          double  d;
281          int     p[4];
282          int     i, j;
168 –
169 –        if ((x0 == x1) & (y0 == y1))
170 –                return(0.);
283                                                  /* check radius */
284          p[0] = x0; p[1] = y0; p[2] = x1; p[3] = y1;
285          for (i = 4; i--; ) {
# Line 183 | Line 295 | neighborhood_dist2(int x0, int y0, int x1, int y1)
295          return(sum2 / (4*rad*(rad+1) + 1));
296   }
297  
298 < /* Comparison routine needed for sorting price row */
299 < static int
300 < msrt_cmp(void *b, const void *p1, const void *p2)
298 > /* Compute distance between two RBF lobes */
299 > double
300 > lobe_distance(RBFVAL *rbf1, RBFVAL *rbf2)
301   {
302 <        PRICEMAT        *pm = (PRICEMAT *)b;
303 <        float           c1 = pm->prow[*(const short *)p1];
304 <        float           c2 = pm->prow[*(const short *)p2];
305 <
306 <        if (c1 > c2) return(1);
307 <        if (c1 < c2) return(-1);
308 <        return(0);
302 >        FVECT   vfrom, vto;
303 >        double  d, res;
304 >                                        /* quadratic cost function */
305 >        ovec_from_pos(vfrom, rbf1->gx, rbf1->gy);
306 >        ovec_from_pos(vto, rbf2->gx, rbf2->gy);
307 >        d = Acos(DOT(vfrom, vto));
308 >        res = d*d;
309 >        d = R2ANG(rbf2->crad) - R2ANG(rbf1->crad);
310 >        res += d*d;
311 >                                        /* neighborhood difference */
312 >        res += NEIGH_FACT2 * neighborhood_dist2( rbf1->gx, rbf1->gy,
313 >                                                rbf2->gx, rbf2->gy );
314 >        return(res);
315   }
316  
199 – /* Compute (and allocate) migration price matrix for optimization */
200 – static void
201 – price_routes(PRICEMAT *pm, const RBFNODE *from_rbf, const RBFNODE *to_rbf)
202 – {
203 –        FVECT   *vto = (FVECT *)malloc(sizeof(FVECT) * to_rbf->nrbf);
204 –        int     i, j;
317  
206 –        compute_nDSFs(from_rbf, to_rbf);
207 –        pm->nrows = from_rbf->nrbf;
208 –        pm->ncols = to_rbf->nrbf;
209 –        pm->price = (float *)malloc(sizeof(float) * pm->nrows*pm->ncols);
210 –        pm->sord = (short *)malloc(sizeof(short) * pm->nrows*pm->ncols);
211 –        
212 –        if ((pm->price == NULL) | (pm->sord == NULL) | (vto == NULL)) {
213 –                fprintf(stderr, "%s: Out of memory in migration_costs()\n",
214 –                                progname);
215 –                exit(1);
216 –        }
217 –        for (j = to_rbf->nrbf; j--; )           /* save repetitive ops. */
218 –                ovec_from_pos(vto[j], to_rbf->rbfa[j].gx, to_rbf->rbfa[j].gy);
219 –
220 –        for (i = from_rbf->nrbf; i--; ) {
221 –            const double        from_ang = R2ANG(from_rbf->rbfa[i].crad);
222 –            FVECT               vfrom;
223 –            short               *srow;
224 –            ovec_from_pos(vfrom, from_rbf->rbfa[i].gx, from_rbf->rbfa[i].gy);
225 –            pm->prow = pricerow(pm,i);
226 –            srow = psortrow(pm,i);
227 –            for (j = to_rbf->nrbf; j--; ) {
228 –                double          d;              /* quadratic cost function */
229 –                d = Acos(DOT(vfrom, vto[j]));
230 –                pm->prow[j] = d*d;
231 –                d = R2ANG(to_rbf->rbfa[j].crad) - from_ang;
232 –                pm->prow[j] += d*d;
233 –                                                /* neighborhood difference */
234 –                pm->prow[j] += NEIGH_FACT2 * neighborhood_dist2(
235 –                                from_rbf->rbfa[i].gx, from_rbf->rbfa[i].gy,
236 –                                to_rbf->rbfa[j].gx, to_rbf->rbfa[j].gy );
237 –                srow[j] = j;
238 –            }
239 –            qsort_r(srow, pm->ncols, sizeof(short), pm, &msrt_cmp);
240 –        }
241 –        free(vto);
242 – }
243 –
244 – /* Free price matrix */
245 – static void
246 – free_routes(PRICEMAT *pm)
247 – {
248 –        free(pm->price); pm->price = NULL;
249 –        free(pm->sord); pm->sord = NULL;
250 – }
251 –
252 – /* Compute minimum (optimistic) cost for moving the given source material */
253 – static double
254 – min_cost(double amt2move, const double *avail, const PRICEMAT *pm, int s)
255 – {
256 –        const short     *srow = psortrow(pm,s);
257 –        const float     *prow = pricerow(pm,s);
258 –        double          total_cost = 0;
259 –        int             j;
260 –                                                /* move cheapest first */
261 –        for (j = 0; (j < pm->ncols) & (amt2move > FTINY); j++) {
262 –                int     d = srow[j];
263 –                double  amt = (amt2move < avail[d]) ? amt2move : avail[d];
264 –
265 –                total_cost += amt * prow[d];
266 –                amt2move -= amt;
267 –        }
268 –        return(total_cost);
269 – }
270 –
271 – typedef struct {
272 –        short   s, d;           /* source and destination */
273 –        float   dc;             /* discount to push inventory */
274 – } ROWSENT;              /* row sort entry */
275 –
276 – /* Compare entries by discounted moving price */
277 – static int
278 – rmovcmp(void *b, const void *p1, const void *p2)
279 – {
280 –        PRICEMAT        *pm = (PRICEMAT *)b;
281 –        const ROWSENT   *re1 = (const ROWSENT *)p1;
282 –        const ROWSENT   *re2 = (const ROWSENT *)p2;
283 –        double          price_diff;
284 –
285 –        if (re1->d < 0) return(re2->d >= 0);
286 –        if (re2->d < 0) return(-1);
287 –        price_diff = re1->dc*pricerow(pm,re1->s)[re1->d] -
288 –                        re2->dc*pricerow(pm,re2->s)[re2->d];
289 –        if (price_diff > 0) return(1);
290 –        if (price_diff < 0) return(-1);
291 –        return(0);
292 – }
293 –
294 – /* Take a step in migration by choosing reasonable bucket to transfer */
295 – static double
296 – migration_step(MIGRATION *mig, double *src_rem, double *dst_rem, PRICEMAT *pm)
297 – {
298 –        const int       max2check = 100;
299 –        const double    maxamt = 1./(double)pm->ncols;
300 –        const double    minamt = maxamt*1e-4;
301 –        double          *src_cost;
302 –        ROWSENT         *rord;
303 –        struct {
304 –                int     s, d;   /* source and destination */
305 –                double  price;  /* cost per amount moved */
306 –                double  amt;    /* amount we can move */
307 –        } cur, best;
308 –        int             r2check, i, ri;
309 –        /*
310 –         * Check cheapest available routes only -- a higher adjusted
311 –         * destination price implies that another source is closer, so
312 –         * we can hold off considering more expensive options until
313 –         * some other (hopefully better) moves have been made.
314 –         * A discount based on source remaining is supposed to prioritize
315 –         * movement from large lobes, but it doesn't seem to do much,
316 –         * so we have it set to 1.0 at the moment.
317 –         */
318 – #define discount(qr)    1.0
319 –                                                /* most promising row order */
320 –        rord = (ROWSENT *)malloc(sizeof(ROWSENT)*pm->nrows);
321 –        if (rord == NULL)
322 –                goto memerr;
323 –        for (ri = pm->nrows; ri--; ) {
324 –            rord[ri].s = ri;
325 –            rord[ri].d = -1;
326 –            rord[ri].dc = 1.f;
327 –            if (src_rem[ri] <= minamt)          /* enough source material? */
328 –                    continue;
329 –            for (i = 0; i < pm->ncols; i++)
330 –                if (dst_rem[ rord[ri].d = psortrow(pm,ri)[i] ] > minamt)
331 –                        break;
332 –            if (i >= pm->ncols) {               /* moved all we can? */
333 –                free(rord);
334 –                return(.0);
335 –            }
336 –            rord[ri].dc = discount(src_rem[ri]);
337 –        }
338 –        if (pm->nrows > max2check)              /* sort if too many sources */
339 –                qsort_r(rord, pm->nrows, sizeof(ROWSENT), pm, &rmovcmp);
340 –                                                /* allocate cost array */
341 –        src_cost = (double *)malloc(sizeof(double)*pm->nrows);
342 –        if (src_cost == NULL)
343 –                goto memerr;
344 –        for (i = pm->nrows; i--; )              /* starting costs for diff. */
345 –                src_cost[i] = min_cost(src_rem[i], dst_rem, pm, i);
346 –                                                /* find best source & dest. */
347 –        best.s = best.d = -1; best.price = FHUGE; best.amt = 0;
348 –        if ((r2check = pm->nrows) > max2check)
349 –                r2check = max2check;            /* put a limit on search */
350 –        for (ri = 0; ri < r2check; ri++) {      /* check each source row */
351 –            double      cost_others = 0;
352 –            cur.s = rord[ri].s;
353 –            if ((cur.d = rord[ri].d) < 0 ||
354 –                        rord[ri].dc*pricerow(pm,cur.s)[cur.d] >= best.price) {
355 –                if (pm->nrows > max2check) break;       /* sorted end */
356 –                continue;                       /* else skip this one */
357 –            }
358 –            cur.amt = (src_rem[cur.s] < dst_rem[cur.d]) ?
359 –                                src_rem[cur.s] : dst_rem[cur.d];
360 –                                                /* don't just leave smidgen */
361 –            if (cur.amt > maxamt*1.02) cur.amt = maxamt;
362 –            dst_rem[cur.d] -= cur.amt;          /* add up opportunity costs */
363 –            for (i = pm->nrows; i--; )
364 –                if (i != cur.s)
365 –                    cost_others += min_cost(src_rem[i], dst_rem, pm, i)
366 –                                        - src_cost[i];
367 –            dst_rem[cur.d] += cur.amt;          /* undo trial move */
368 –                                                /* discount effective price */
369 –            cur.price = ( pricerow(pm,cur.s)[cur.d] + cost_others/cur.amt ) *
370 –                                        rord[ri].dc;
371 –            if (cur.price < best.price)         /* are we better than best? */
372 –                best = cur;
373 –        }
374 –        free(src_cost);                         /* clean up */
375 –        free(rord);
376 –        if ((best.s < 0) | (best.d < 0))        /* nothing left to move? */
377 –                return(.0);
378 –                                                /* else make the actual move */
379 –        mtx_coef(mig,best.s,best.d) += best.amt;
380 –        src_rem[best.s] -= best.amt;
381 –        dst_rem[best.d] -= best.amt;
382 –        return(best.amt);
383 – memerr:
384 –        fprintf(stderr, "%s: Out of memory in migration_step()\n", progname);
385 –        exit(1);
386 – #undef discount
387 – }
388 –
318   /* Compute and insert migration along directed edge (may fork child) */
319   static MIGRATION *
320   create_migration(RBFNODE *from_rbf, RBFNODE *to_rbf)
321   {
393 –        const double    end_thresh = 5e-6;
394 –        PRICEMAT        pmtx;
322          MIGRATION       *newmig;
396 –        double          *src_rem, *dst_rem;
397 –        double          total_rem = 1., move_amt;
323          int             i, j;
324                                                  /* check if exists already */
325          for (newmig = from_rbf->ejl; newmig != NULL;
# Line 414 | Line 339 | create_migration(RBFNODE *from_rbf, RBFNODE *to_rbf)
339          newmig = new_migration(from_rbf, to_rbf);
340          if (run_subprocess())
341                  return(newmig);                 /* child continues */
417 –        price_routes(&pmtx, from_rbf, to_rbf);
418 –        src_rem = (double *)malloc(sizeof(double)*from_rbf->nrbf);
419 –        dst_rem = (double *)malloc(sizeof(double)*to_rbf->nrbf);
420 –        if ((src_rem == NULL) | (dst_rem == NULL)) {
421 –                fprintf(stderr, "%s: Out of memory in create_migration()\n",
422 –                                progname);
423 –                exit(1);
424 –        }
425 –                                                /* starting quantities */
426 –        memset(newmig->mtx, 0, sizeof(float)*from_rbf->nrbf*to_rbf->nrbf);
427 –        for (i = from_rbf->nrbf; i--; )
428 –                src_rem[i] = rbf_volume(&from_rbf->rbfa[i]) / from_rbf->vtotal;
429 –        for (j = to_rbf->nrbf; j--; )
430 –                dst_rem[j] = rbf_volume(&to_rbf->rbfa[j]) / to_rbf->vtotal;
342  
343 <        do {                                    /* move a bit at a time */
344 <                move_amt = migration_step(newmig, src_rem, dst_rem, &pmtx);
345 <                total_rem -= move_amt;
435 <        } while ((total_rem > end_thresh) & (move_amt > 0));
343 >                                                /* compute transport plan */
344 >        compute_nDSFs(from_rbf, to_rbf);
345 >        plan_transport(newmig);
346  
347          for (i = from_rbf->nrbf; i--; ) {       /* normalize final matrix */
348              double      nf = rbf_volume(&from_rbf->rbfa[i]);
# Line 442 | Line 352 | create_migration(RBFNODE *from_rbf, RBFNODE *to_rbf)
352                  mtx_coef(newmig,i,j) *= nf;     /* row now sums to 1.0 */
353          }
354          end_subprocess();                       /* exit here if subprocess */
445 –        free_routes(&pmtx);                     /* free working arrays */
446 –        free(src_rem);
447 –        free(dst_rem);
355          return(newmig);
356   }
357  
# Line 534 | Line 441 | mesh_from_edge(MIGRATION *edge)
441                                  ej1 = create_migration(tvert[0], edge->rbfv[1]);
442                          mesh_from_edge(ej0);
443                          mesh_from_edge(ej1);
444 +                        return;
445                  }
446 <        } else if (tvert[1] == NULL) {          /* grow mesh on left */
446 >        }
447 >        if (tvert[1] == NULL) {                 /* grow mesh on left */
448                  tvert[1] = find_chull_vert(edge->rbfv[1], edge->rbfv[0]);
449                  if (tvert[1] != NULL) {
450                          if (tvert[1]->ord > edge->rbfv[0]->ord)
# Line 556 | Line 465 | mesh_from_edge(MIGRATION *edge)
465   static void
466   check_normal_incidence(void)
467   {
468 <        static const FVECT      norm_vec = {.0, .0, 1.};
468 >        static FVECT            norm_vec = {.0, .0, 1.};
469          const int               saved_nprocs = nprocs;
470          RBFNODE                 *near_rbf, *mir_rbf, *rbf;
471          double                  bestd;
# Line 579 | Line 488 | check_normal_incidence(void)
488                  default:
489                          return;                 /* else we can interpolate */
490                  }
491 <                for (rbf = near_rbf->next; rbf != NULL; rbf = rbf->next) {
491 >                for (rbf = dsf_list; rbf != NULL; rbf = rbf->next) {
492                          const double    d = input_orient*rbf->invec[2];
493                          if (d >= 1.-2.*FTINY)
494                                  return;         /* seems we have normal */
# Line 606 | Line 515 | check_normal_incidence(void)
515          memcpy(mir_rbf, near_rbf, n);
516          mir_rbf->ord = near_rbf->ord - 1;       /* not used, I think */
517          mir_rbf->next = NULL;
518 +        mir_rbf->ejl = NULL;
519          rev_rbf_symmetry(mir_rbf, MIRROR_X|MIRROR_Y);
520          nprocs = 1;                             /* compute migration matrix */
521 <        if (mig_list != create_migration(mir_rbf, near_rbf))
521 >        if (create_migration(mir_rbf, near_rbf) == NULL)
522                  exit(1);                        /* XXX should never happen! */
523 <                                                /* interpolate normal dist. */
524 <        rbf = e_advect_rbf(mig_list, norm_vec, 2*near_rbf->nrbf);
523 >        norm_vec[2] = input_orient;             /* interpolate normal dist. */
524 >        rbf = e_advect_rbf(mig_list, norm_vec, 0);
525          nprocs = saved_nprocs;                  /* final clean-up */
526          free(mir_rbf);
527          free(mig_list);
# Line 628 | Line 538 | memerr:
538   void
539   build_mesh(void)
540   {
541 +        int             nrbfs = 0, nmigs = 0;
542          double          best2 = M_PI*M_PI;
543          RBFNODE         *shrt_edj[2];
544          RBFNODE         *rbf0, *rbf1;
545 +        const MIGRATION *ej;
546 +                                                /* average specular peak */
547 +        comp_bsdf_spec();
548                                                  /* add normal if needed */
549          check_normal_incidence();
550                                                  /* check if isotropic */
# Line 642 | Line 556 | build_mesh(void)
556                  return;
557          }
558          shrt_edj[0] = shrt_edj[1] = NULL;       /* start w/ shortest edge */
559 <        for (rbf0 = dsf_list; rbf0 != NULL; rbf0 = rbf0->next)
559 >        for (rbf0 = dsf_list; rbf0 != NULL; rbf0 = rbf0->next) {
560              for (rbf1 = rbf0->next; rbf1 != NULL; rbf1 = rbf1->next) {
561                  double  dist2 = 2. - 2.*DOT(rbf0->invec,rbf1->invec);
562                  if (dist2 < best2) {
# Line 650 | Line 564 | build_mesh(void)
564                          shrt_edj[1] = rbf1;
565                          best2 = dist2;
566                  }
567 +            }
568 +            ++nrbfs;
569          }
570          if (shrt_edj[0] == NULL) {
571                  fprintf(stderr, "%s: Cannot find shortest edge\n", progname);
# Line 660 | Line 576 | build_mesh(void)
576                  mesh_from_edge(create_migration(shrt_edj[0], shrt_edj[1]));
577          else
578                  mesh_from_edge(create_migration(shrt_edj[1], shrt_edj[0]));
579 +                                                /* count up edges */
580 +        for (ej = mig_list; ej != NULL; ej = ej->next)
581 +                ++nmigs;
582 +        if (nmigs < nrbfs-1)                    /* did meshing fail? */
583 +                fprintf(stderr,
584 +            "%s: warning - %d incident directions but only %d interpolant(s)\n",
585 +                                progname, nrbfs, nmigs);
586                                                  /* complete migrations */
587          await_children(nchild);
588   }

Diff Legend

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