| 104 |
|
int |
| 105 |
|
use_symmetry(FVECT vec) |
| 106 |
|
{ |
| 107 |
< |
const double phi = get_phi360(vec); |
| 107 |
> |
double phi = get_phi360(vec); |
| 108 |
> |
/* because of -0. issue */ |
| 109 |
> |
while (phi >= 360.) phi -= 360.; |
| 110 |
> |
while (phi < 0.) phi += 360.; |
| 111 |
|
|
| 112 |
|
switch (inp_coverage) { |
| 113 |
|
case INP_QUAD1|INP_QUAD2|INP_QUAD3|INP_QUAD4: |
| 225 |
|
} |
| 226 |
|
|
| 227 |
|
/* Compute outgoing vector from grid position */ |
| 228 |
+ |
#if 1 |
| 229 |
|
void |
| 230 |
|
ovec_from_pos(FVECT vec, int xpos, int ypos) |
| 231 |
< |
{ |
| 232 |
< |
double uv[2]; |
| 231 |
> |
{ /* precomputed table version */ |
| 232 |
> |
static int qsiz = 0; |
| 233 |
> |
static float (*q_uv)[2] = NULL; |
| 234 |
> |
|
| 235 |
> |
if (vec == NULL) { /* just free table? */ |
| 236 |
> |
if (q_uv) free(q_uv); |
| 237 |
> |
qsiz = 0; |
| 238 |
> |
return; |
| 239 |
> |
} |
| 240 |
> |
if (qsiz != grid_res>>1) { |
| 241 |
> |
int x, y; /* (re)make positive quadrant table */ |
| 242 |
> |
RREAL uv[2]; |
| 243 |
> |
double r; |
| 244 |
> |
if (q_uv) free(q_uv); |
| 245 |
> |
qsiz = grid_res>>1; |
| 246 |
> |
q_uv = (float (*)[2])malloc(sizeof(float)*2*qsiz*qsiz); |
| 247 |
> |
for (y = qsiz; y--; ) |
| 248 |
> |
for (x = qsiz; x--; ) { |
| 249 |
> |
square2disk(uv, 0.5 + (x+.5)/grid_res, |
| 250 |
> |
0.5 + (y+.5)/grid_res); |
| 251 |
> |
/* uniform hemispherical projection */ |
| 252 |
> |
r = sqrt(2. - uv[0]*uv[0] - uv[1]*uv[1]); |
| 253 |
> |
q_uv[qsiz*y + x][0] = (float)(r*uv[0]); |
| 254 |
> |
q_uv[qsiz*y + x][1] = (float)(r*uv[1]); |
| 255 |
> |
} |
| 256 |
> |
} |
| 257 |
> |
/* put in positive quadrant */ |
| 258 |
> |
if (xpos >= qsiz) { xpos -= qsiz; vec[0] = 1.; } |
| 259 |
> |
else { xpos = qsiz-1 - xpos; vec[0] = -1.; } |
| 260 |
> |
if (ypos >= qsiz) { ypos -= qsiz; vec[1] = 1.; } |
| 261 |
> |
else { ypos = qsiz-1 - ypos; vec[1] = -1.; } |
| 262 |
> |
|
| 263 |
> |
vec[0] *= (RREAL)q_uv[qsiz*ypos + xpos][0]; |
| 264 |
> |
vec[1] *= (RREAL)q_uv[qsiz*ypos + xpos][1]; |
| 265 |
> |
vec[2] = output_orient*sqrt(1. - vec[0]*vec[0] - vec[1]*vec[1]); |
| 266 |
> |
} |
| 267 |
> |
#else |
| 268 |
> |
void |
| 269 |
> |
ovec_from_pos(FVECT vec, int xpos, int ypos) |
| 270 |
> |
{ /* table-free version */ |
| 271 |
> |
RREAL uv[2]; |
| 272 |
|
double r2; |
| 273 |
< |
|
| 274 |
< |
SDsquare2disk(uv, (xpos+.5)/grid_res, (ypos+.5)/grid_res); |
| 273 |
> |
|
| 274 |
> |
if (vec == NULL) |
| 275 |
> |
return; |
| 276 |
> |
|
| 277 |
> |
square2disk(uv, (xpos+.5)/grid_res, (ypos+.5)/grid_res); |
| 278 |
|
/* uniform hemispherical projection */ |
| 279 |
|
r2 = uv[0]*uv[0] + uv[1]*uv[1]; |
| 280 |
|
vec[0] = vec[1] = sqrt(2. - r2); |
| 282 |
|
vec[1] *= uv[1]; |
| 283 |
|
vec[2] = output_orient*(1. - r2); |
| 284 |
|
} |
| 285 |
+ |
#endif |
| 286 |
|
|
| 287 |
|
/* Compute grid position from normalized input/output vector */ |
| 288 |
|
void |
| 289 |
|
pos_from_vec(int pos[2], const FVECT vec) |
| 290 |
|
{ |
| 291 |
< |
double sq[2]; /* uniform hemispherical projection */ |
| 291 |
> |
RREAL sq[2]; /* uniform hemispherical projection */ |
| 292 |
|
double norm = 1./sqrt(1. + fabs(vec[2])); |
| 293 |
|
|
| 294 |
< |
SDdisk2square(sq, vec[0]*norm, vec[1]*norm); |
| 294 |
> |
disk2square(sq, vec[0]*norm, vec[1]*norm); |
| 295 |
|
|
| 296 |
|
pos[0] = (int)(sq[0]*grid_res); |
| 297 |
|
pos[1] = (int)(sq[1]*grid_res); |
| 525 |
|
double t, full_dist; |
| 526 |
|
/* get relative position */ |
| 527 |
|
t = Acos(DOT(invec, mig->rbfv[0]->invec)); |
| 528 |
< |
if (t < M_PI/grid_res) { /* near first DSF */ |
| 528 |
> |
if (t <= .001) { /* near first DSF */ |
| 529 |
|
n = sizeof(RBFNODE) + sizeof(RBFVAL)*(mig->rbfv[0]->nrbf-1); |
| 530 |
|
rbf = (RBFNODE *)malloc(n); |
| 531 |
|
if (rbf == NULL) |
| 535 |
|
return(rbf); |
| 536 |
|
} |
| 537 |
|
full_dist = acos(DOT(mig->rbfv[0]->invec, mig->rbfv[1]->invec)); |
| 538 |
< |
if (t > full_dist-M_PI/grid_res) { /* near second DSF */ |
| 538 |
> |
if (t >= full_dist-.001) { /* near second DSF */ |
| 539 |
|
n = sizeof(RBFNODE) + sizeof(RBFVAL)*(mig->rbfv[1]->nrbf-1); |
| 540 |
|
rbf = (RBFNODE *)malloc(n); |
| 541 |
|
if (rbf == NULL) |
