--- ray/src/cv/bsdfmesh.c 2014/03/12 00:39:43 2.23 +++ ray/src/cv/bsdfmesh.c 2014/08/21 10:33:48 2.30 @@ -1,5 +1,5 @@ #ifndef lint -static const char RCSid[] = "$Id: bsdfmesh.c,v 2.23 2014/03/12 00:39:43 greg Exp $"; +static const char RCSid[] = "$Id: bsdfmesh.c,v 2.30 2014/08/21 10:33:48 greg Exp $"; #endif /* * Create BSDF advection mesh from radial basis functions. @@ -27,16 +27,94 @@ int nprocs = 1; /* number of children (-1 in child) */ static int nchild = 0; -typedef struct { - int nrows, ncols; /* array size (matches migration) */ - float *price; /* migration prices */ - short *sord; /* sort for each row, low to high */ - float *prow; /* current price row */ -} PRICEMAT; /* sorted pricing matrix */ +/* Compute average DSF value at the given radius from central vector */ +static double +eval_DSFsurround(const RBFNODE *rbf, const FVECT outvec, const double rad) +{ + const int ninc = 12; + const double phinc = 2.*M_PI/ninc; + double sum = 0; + int n = 0; + FVECT tvec; + int i; + /* compute initial vector */ + if (output_orient*outvec[2] >= 1.-FTINY) { + tvec[0] = tvec[2] = 0; + tvec[1] = 1; + } else { + tvec[0] = tvec[1] = 0; + tvec[2] = 1; + } + geodesic(tvec, outvec, tvec, rad, GEOD_RAD); + /* average surrounding DSF */ + for (i = 0; i < ninc; i++) { + if (i) spinvector(tvec, tvec, outvec, phinc); + if (tvec[2] > 0 ^ output_orient > 0) + continue; + sum += eval_rbfrep(rbf, tvec) * output_orient*tvec[2]; + ++n; + } + if (n < 2) /* should never happen! */ + return(sum); + return(sum/(double)n); +} -#define pricerow(p,i) ((p)->price + (i)*(p)->ncols) -#define psortrow(p,i) ((p)->sord + (i)*(p)->ncols) +/* Estimate single-lobe radius for DSF at the given outgoing angle */ +static double +est_DSFrad(const RBFNODE *rbf, const FVECT outvec) +{ + const double rad_epsilon = 0.03; + const double DSFtarget = 0.60653066 * eval_rbfrep(rbf,outvec) + * output_orient*outvec[2]; + double inside_rad = rad_epsilon; + double outside_rad = 0.5; + double DSFinside = eval_DSFsurround(rbf, outvec, inside_rad); + double DSFoutside = eval_DSFsurround(rbf, outvec, outside_rad); +#define interp_rad inside_rad + (outside_rad-inside_rad) * \ + (DSFtarget-DSFinside) / (DSFoutside-DSFinside) + /* interpolation search */ + while (outside_rad-inside_rad > rad_epsilon) { + double test_rad = interp_rad; + double DSFtest = eval_DSFsurround(rbf, outvec, test_rad); + if (DSFtarget < DSFtest) { + inside_rad = test_rad; + DSFinside = DSFtest; + } else { + outside_rad = test_rad; + DSFoutside = DSFtest; + } + } + return(interp_rad); +#undef interp_rad +} +/* Compute average BSDF peak from current DSF's */ +static void +comp_bsdf_spec(void) +{ + double peak_sum = 0; + double rad_sum = 0; + int n = 0; + RBFNODE *rbf; + FVECT sdv; + + if (dsf_list == NULL) { + bsdf_spec_peak = 0; + bsdf_spec_crad = 0; + return; + } + for (rbf = dsf_list; rbf != NULL; rbf = rbf->next) { + sdv[0] = -rbf->invec[0]; + sdv[1] = -rbf->invec[1]; + sdv[2] = rbf->invec[2]*(2*(input_orient==output_orient) - 1); + peak_sum += eval_rbfrep(rbf, sdv); + rad_sum += est_DSFrad(rbf, sdv); + ++n; + } + bsdf_spec_peak = peak_sum/(double)n; + bsdf_spec_crad = ANG2R( rad_sum/(double)n ); +} + /* Create a new migration holder (sharing memory for multiprocessing) */ static MIGRATION * new_migration(RBFNODE *from_rbf, RBFNODE *to_rbf) @@ -165,9 +243,6 @@ neighborhood_dist2(int x0, int y0, int x1, int y1) double d; int p[4]; int i, j; - - if ((x0 == x1) & (y0 == y1)) - return(0.); /* check radius */ p[0] = x0; p[1] = y0; p[2] = x1; p[3] = y1; for (i = 4; i--; ) { @@ -183,218 +258,31 @@ neighborhood_dist2(int x0, int y0, int x1, int y1) return(sum2 / (4*rad*(rad+1) + 1)); } -/* Comparison routine needed for sorting price row */ -static int -msrt_cmp(void *b, const void *p1, const void *p2) +/* Compute distance between two RBF lobes */ +double +lobe_distance(RBFVAL *rbf1, RBFVAL *rbf2) { - PRICEMAT *pm = (PRICEMAT *)b; - float c1 = pm->prow[*(const short *)p1]; - float c2 = pm->prow[*(const short *)p2]; - - if (c1 > c2) return(1); - if (c1 < c2) return(-1); - return(0); + FVECT vfrom, vto; + double d, res; + /* quadratic cost function */ + ovec_from_pos(vfrom, rbf1->gx, rbf1->gy); + ovec_from_pos(vto, rbf2->gx, rbf2->gy); + d = Acos(DOT(vfrom, vto)); + res = d*d; + d = R2ANG(rbf2->crad) - R2ANG(rbf1->crad); + res += d*d; + /* neighborhood difference */ + res += NEIGH_FACT2 * neighborhood_dist2( rbf1->gx, rbf1->gy, + rbf2->gx, rbf2->gy ); + return(res); } -/* Compute (and allocate) migration price matrix for optimization */ -static void -price_routes(PRICEMAT *pm, const RBFNODE *from_rbf, const RBFNODE *to_rbf) -{ - FVECT *vto = (FVECT *)malloc(sizeof(FVECT) * to_rbf->nrbf); - int i, j; - compute_nDSFs(from_rbf, to_rbf); - pm->nrows = from_rbf->nrbf; - pm->ncols = to_rbf->nrbf; - pm->price = (float *)malloc(sizeof(float) * pm->nrows*pm->ncols); - pm->sord = (short *)malloc(sizeof(short) * pm->nrows*pm->ncols); - - if ((pm->price == NULL) | (pm->sord == NULL) | (vto == NULL)) { - fprintf(stderr, "%s: Out of memory in migration_costs()\n", - progname); - exit(1); - } - for (j = to_rbf->nrbf; j--; ) /* save repetitive ops. */ - ovec_from_pos(vto[j], to_rbf->rbfa[j].gx, to_rbf->rbfa[j].gy); - - for (i = from_rbf->nrbf; i--; ) { - const double from_ang = R2ANG(from_rbf->rbfa[i].crad); - FVECT vfrom; - short *srow; - ovec_from_pos(vfrom, from_rbf->rbfa[i].gx, from_rbf->rbfa[i].gy); - pm->prow = pricerow(pm,i); - srow = psortrow(pm,i); - for (j = to_rbf->nrbf; j--; ) { - double d; /* quadratic cost function */ - d = Acos(DOT(vfrom, vto[j])); - pm->prow[j] = d*d; - d = R2ANG(to_rbf->rbfa[j].crad) - from_ang; - pm->prow[j] += d*d; - /* neighborhood difference */ - pm->prow[j] += NEIGH_FACT2 * neighborhood_dist2( - from_rbf->rbfa[i].gx, from_rbf->rbfa[i].gy, - to_rbf->rbfa[j].gx, to_rbf->rbfa[j].gy ); - srow[j] = j; - } - qsort_r(srow, pm->ncols, sizeof(short), pm, &msrt_cmp); - } - free(vto); -} - -/* Free price matrix */ -static void -free_routes(PRICEMAT *pm) -{ - free(pm->price); pm->price = NULL; - free(pm->sord); pm->sord = NULL; -} - -/* Compute minimum (optimistic) cost for moving the given source material */ -static double -min_cost(double amt2move, const double *avail, const PRICEMAT *pm, int s) -{ - const short *srow = psortrow(pm,s); - const float *prow = pricerow(pm,s); - double total_cost = 0; - int j; - /* move cheapest first */ - for (j = 0; (j < pm->ncols) & (amt2move > FTINY); j++) { - int d = srow[j]; - double amt = (amt2move < avail[d]) ? amt2move : avail[d]; - - total_cost += amt * prow[d]; - amt2move -= amt; - } - return(total_cost); -} - -typedef struct { - short s, d; /* source and destination */ - float dc; /* discount to push inventory */ -} ROWSENT; /* row sort entry */ - -/* Compare entries by discounted moving price */ -static int -rmovcmp(void *b, const void *p1, const void *p2) -{ - PRICEMAT *pm = (PRICEMAT *)b; - const ROWSENT *re1 = (const ROWSENT *)p1; - const ROWSENT *re2 = (const ROWSENT *)p2; - double price_diff; - - if (re1->d < 0) return(re2->d >= 0); - if (re2->d < 0) return(-1); - price_diff = re1->dc*pricerow(pm,re1->s)[re1->d] - - re2->dc*pricerow(pm,re2->s)[re2->d]; - if (price_diff > 0) return(1); - if (price_diff < 0) return(-1); - return(0); -} - -/* Take a step in migration by choosing reasonable bucket to transfer */ -static double -migration_step(MIGRATION *mig, double *src_rem, double *dst_rem, PRICEMAT *pm) -{ - const int max2check = 100; - const double maxamt = 1./(double)pm->ncols; - const double minamt = maxamt*1e-4; - double *src_cost; - ROWSENT *rord; - struct { - int s, d; /* source and destination */ - double price; /* cost per amount moved */ - double amt; /* amount we can move */ - } cur, best; - int r2check, i, ri; - /* - * Check cheapest available routes only -- a higher adjusted - * destination price implies that another source is closer, so - * we can hold off considering more expensive options until - * some other (hopefully better) moves have been made. - * A discount based on source remaining is supposed to prioritize - * movement from large lobes, but it doesn't seem to do much, - * so we have it set to 1.0 at the moment. - */ -#define discount(qr) 1.0 - /* most promising row order */ - rord = (ROWSENT *)malloc(sizeof(ROWSENT)*pm->nrows); - if (rord == NULL) - goto memerr; - for (ri = pm->nrows; ri--; ) { - rord[ri].s = ri; - rord[ri].d = -1; - rord[ri].dc = 1.f; - if (src_rem[ri] <= minamt) /* enough source material? */ - continue; - for (i = 0; i < pm->ncols; i++) - if (dst_rem[ rord[ri].d = psortrow(pm,ri)[i] ] > minamt) - break; - if (i >= pm->ncols) { /* moved all we can? */ - free(rord); - return(.0); - } - rord[ri].dc = discount(src_rem[ri]); - } - if (pm->nrows > max2check) /* sort if too many sources */ - qsort_r(rord, pm->nrows, sizeof(ROWSENT), pm, &rmovcmp); - /* allocate cost array */ - src_cost = (double *)malloc(sizeof(double)*pm->nrows); - if (src_cost == NULL) - goto memerr; - for (i = pm->nrows; i--; ) /* starting costs for diff. */ - src_cost[i] = min_cost(src_rem[i], dst_rem, pm, i); - /* find best source & dest. */ - best.s = best.d = -1; best.price = FHUGE; best.amt = 0; - if ((r2check = pm->nrows) > max2check) - r2check = max2check; /* put a limit on search */ - for (ri = 0; ri < r2check; ri++) { /* check each source row */ - double cost_others = 0; - cur.s = rord[ri].s; - if ((cur.d = rord[ri].d) < 0 || - rord[ri].dc*pricerow(pm,cur.s)[cur.d] >= best.price) { - if (pm->nrows > max2check) break; /* sorted end */ - continue; /* else skip this one */ - } - cur.amt = (src_rem[cur.s] < dst_rem[cur.d]) ? - src_rem[cur.s] : dst_rem[cur.d]; - /* don't just leave smidgen */ - if (cur.amt > maxamt*1.02) cur.amt = maxamt; - dst_rem[cur.d] -= cur.amt; /* add up opportunity costs */ - for (i = pm->nrows; i--; ) - if (i != cur.s) - cost_others += min_cost(src_rem[i], dst_rem, pm, i) - - src_cost[i]; - dst_rem[cur.d] += cur.amt; /* undo trial move */ - /* discount effective price */ - cur.price = ( pricerow(pm,cur.s)[cur.d] + cost_others/cur.amt ) * - rord[ri].dc; - if (cur.price < best.price) /* are we better than best? */ - best = cur; - } - free(src_cost); /* clean up */ - free(rord); - if ((best.s < 0) | (best.d < 0)) /* nothing left to move? */ - return(.0); - /* else make the actual move */ - mtx_coef(mig,best.s,best.d) += best.amt; - src_rem[best.s] -= best.amt; - dst_rem[best.d] -= best.amt; - return(best.amt); -memerr: - fprintf(stderr, "%s: Out of memory in migration_step()\n", progname); - exit(1); -#undef discount -} - /* Compute and insert migration along directed edge (may fork child) */ static MIGRATION * create_migration(RBFNODE *from_rbf, RBFNODE *to_rbf) { - const double end_thresh = 5e-6; - PRICEMAT pmtx; MIGRATION *newmig; - double *src_rem, *dst_rem; - double total_rem = 1., move_amt; int i, j; /* check if exists already */ for (newmig = from_rbf->ejl; newmig != NULL; @@ -414,25 +302,10 @@ create_migration(RBFNODE *from_rbf, RBFNODE *to_rbf) newmig = new_migration(from_rbf, to_rbf); if (run_subprocess()) return(newmig); /* child continues */ - price_routes(&pmtx, from_rbf, to_rbf); - src_rem = (double *)malloc(sizeof(double)*from_rbf->nrbf); - dst_rem = (double *)malloc(sizeof(double)*to_rbf->nrbf); - if ((src_rem == NULL) | (dst_rem == NULL)) { - fprintf(stderr, "%s: Out of memory in create_migration()\n", - progname); - exit(1); - } - /* starting quantities */ - memset(newmig->mtx, 0, sizeof(float)*from_rbf->nrbf*to_rbf->nrbf); - for (i = from_rbf->nrbf; i--; ) - src_rem[i] = rbf_volume(&from_rbf->rbfa[i]) / from_rbf->vtotal; - for (j = to_rbf->nrbf; j--; ) - dst_rem[j] = rbf_volume(&to_rbf->rbfa[j]) / to_rbf->vtotal; - do { /* move a bit at a time */ - move_amt = migration_step(newmig, src_rem, dst_rem, &pmtx); - total_rem -= move_amt; - } while ((total_rem > end_thresh) & (move_amt > 0)); + /* compute transport plan */ + compute_nDSFs(from_rbf, to_rbf); + plan_transport(newmig); for (i = from_rbf->nrbf; i--; ) { /* normalize final matrix */ double nf = rbf_volume(&from_rbf->rbfa[i]); @@ -442,9 +315,6 @@ create_migration(RBFNODE *from_rbf, RBFNODE *to_rbf) mtx_coef(newmig,i,j) *= nf; /* row now sums to 1.0 */ } end_subprocess(); /* exit here if subprocess */ - free_routes(&pmtx); /* free working arrays */ - free(src_rem); - free(dst_rem); return(newmig); } @@ -534,8 +404,10 @@ mesh_from_edge(MIGRATION *edge) ej1 = create_migration(tvert[0], edge->rbfv[1]); mesh_from_edge(ej0); mesh_from_edge(ej1); + return; } - } else if (tvert[1] == NULL) { /* grow mesh on left */ + } + if (tvert[1] == NULL) { /* grow mesh on left */ tvert[1] = find_chull_vert(edge->rbfv[1], edge->rbfv[0]); if (tvert[1] != NULL) { if (tvert[1]->ord > edge->rbfv[0]->ord) @@ -556,13 +428,12 @@ mesh_from_edge(MIGRATION *edge) static void check_normal_incidence(void) { - static const FVECT norm_vec = {.0, .0, 1.}; + static FVECT norm_vec = {.0, .0, 1.}; const int saved_nprocs = nprocs; RBFNODE *near_rbf, *mir_rbf, *rbf; double bestd; int n; - if (dsf_list == NULL) return; /* XXX should be error? */ near_rbf = dsf_list; @@ -612,8 +483,8 @@ check_normal_incidence(void) nprocs = 1; /* compute migration matrix */ if (create_migration(mir_rbf, near_rbf) == NULL) exit(1); /* XXX should never happen! */ - /* interpolate normal dist. */ - rbf = e_advect_rbf(mig_list, norm_vec, 2*near_rbf->nrbf); + norm_vec[2] = input_orient; /* interpolate normal dist. */ + rbf = e_advect_rbf(mig_list, norm_vec, 0); nprocs = saved_nprocs; /* final clean-up */ free(mir_rbf); free(mig_list); @@ -633,6 +504,8 @@ build_mesh(void) double best2 = M_PI*M_PI; RBFNODE *shrt_edj[2]; RBFNODE *rbf0, *rbf1; + /* average specular peak */ + comp_bsdf_spec(); /* add normal if needed */ check_normal_incidence(); /* check if isotropic */