33 |
|
static char ill_horiz[] = "illegal horizontal view size"; |
34 |
|
static char ill_vert[] = "illegal vertical view size"; |
35 |
|
|
36 |
< |
if (v->vaft < -FTINY || (v->vaft > FTINY && v->vaft <= v->vfore)) |
36 |
> |
if ((v->vfore < -FTINY) | (v->vaft < -FTINY) || |
37 |
> |
(v->vaft > FTINY) & (v->vaft <= v->vfore)) |
38 |
|
return("illegal fore/aft clipping plane"); |
39 |
|
|
40 |
|
if (v->vdist <= FTINY) |
170 |
|
direc[0] = v->vdir[0] + x*v->hvec[0] + y*v->vvec[0]; |
171 |
|
direc[1] = v->vdir[1] + x*v->hvec[1] + y*v->vvec[1]; |
172 |
|
direc[2] = v->vdir[2] + x*v->hvec[2] + y*v->vvec[2]; |
173 |
< |
orig[0] = v->vp[0] + v->vfore*direc[0]; |
173 |
< |
orig[1] = v->vp[1] + v->vfore*direc[1]; |
174 |
< |
orig[2] = v->vp[2] + v->vfore*direc[2]; |
173 |
> |
VSUM(orig, v->vp, direc, v->vfore); |
174 |
|
d = normalize(direc); |
175 |
|
return(v->vaft > FTINY ? (v->vaft - v->vfore)*d : 0.0); |
176 |
|
case VT_HEM: /* hemispherical fisheye */ |
181 |
|
direc[0] = z*v->vdir[0] + x*v->hvec[0] + y*v->vvec[0]; |
182 |
|
direc[1] = z*v->vdir[1] + x*v->hvec[1] + y*v->vvec[1]; |
183 |
|
direc[2] = z*v->vdir[2] + x*v->hvec[2] + y*v->vvec[2]; |
184 |
< |
orig[0] = v->vp[0] + v->vfore*direc[0]; |
186 |
< |
orig[1] = v->vp[1] + v->vfore*direc[1]; |
187 |
< |
orig[2] = v->vp[2] + v->vfore*direc[2]; |
184 |
> |
VSUM(orig, v->vp, direc, v->vfore); |
185 |
|
return(v->vaft > FTINY ? v->vaft - v->vfore : 0.0); |
186 |
|
case VT_CYL: /* cylindrical panorama */ |
187 |
|
d = x * v->horiz * (PI/180.0); |
190 |
|
direc[0] = z*v->vdir[0] + x*v->hvec[0] + y*v->vvec[0]; |
191 |
|
direc[1] = z*v->vdir[1] + x*v->hvec[1] + y*v->vvec[1]; |
192 |
|
direc[2] = z*v->vdir[2] + x*v->hvec[2] + y*v->vvec[2]; |
193 |
< |
orig[0] = v->vp[0] + v->vfore*direc[0]; |
197 |
< |
orig[1] = v->vp[1] + v->vfore*direc[1]; |
198 |
< |
orig[2] = v->vp[2] + v->vfore*direc[2]; |
193 |
> |
VSUM(orig, v->vp, direc, v->vfore); |
194 |
|
d = normalize(direc); |
195 |
|
return(v->vaft > FTINY ? (v->vaft - v->vfore)*d : 0.0); |
196 |
|
case VT_ANG: /* angular fisheye */ |
207 |
|
direc[0] = z*v->vdir[0] + x*v->hvec[0] + y*v->vvec[0]; |
208 |
|
direc[1] = z*v->vdir[1] + x*v->hvec[1] + y*v->vvec[1]; |
209 |
|
direc[2] = z*v->vdir[2] + x*v->hvec[2] + y*v->vvec[2]; |
210 |
< |
orig[0] = v->vp[0] + v->vfore*direc[0]; |
216 |
< |
orig[1] = v->vp[1] + v->vfore*direc[1]; |
217 |
< |
orig[2] = v->vp[2] + v->vfore*direc[2]; |
210 |
> |
VSUM(orig, v->vp, direc, v->vfore); |
211 |
|
return(v->vaft > FTINY ? v->vaft - v->vfore : 0.0); |
212 |
|
case VT_PLS: /* planispheric fisheye */ |
213 |
|
x *= sqrt(v->hn2); |
214 |
|
y *= sqrt(v->vn2); |
215 |
|
d = x*x + y*y; |
216 |
|
z = (1. - d)/(1. + d); |
217 |
< |
d = d <= FTINY*FTINY ? PI : sqrt((1.0 - z*z)/d); |
218 |
< |
x *= d; |
226 |
< |
y *= d; |
217 |
> |
x *= (1. + z); |
218 |
> |
y *= (1. + z); |
219 |
|
direc[0] = z*v->vdir[0] + x*v->hvec[0] + y*v->vvec[0]; |
220 |
|
direc[1] = z*v->vdir[1] + x*v->hvec[1] + y*v->vvec[1]; |
221 |
|
direc[2] = z*v->vdir[2] + x*v->hvec[2] + y*v->vvec[2]; |
222 |
< |
orig[0] = v->vp[0] + v->vfore*direc[0]; |
231 |
< |
orig[1] = v->vp[1] + v->vfore*direc[1]; |
232 |
< |
orig[2] = v->vp[2] + v->vfore*direc[2]; |
222 |
> |
VSUM(orig, v->vp, direc, v->vfore); |
223 |
|
return(v->vaft > FTINY ? v->vaft - v->vfore : 0.0); |
224 |
|
} |
225 |
|
return(-1.0); |
226 |
|
} |
227 |
|
|
228 |
|
|
229 |
< |
void |
229 |
> |
int |
230 |
|
viewloc( /* find image location for point */ |
231 |
|
FVECT ip, |
232 |
|
VIEW *v, |
233 |
|
FVECT p |
234 |
< |
) |
234 |
> |
) /* Use VL_* flags to interpret return value */ |
235 |
|
{ |
236 |
+ |
int rflags = VL_GOOD; |
237 |
|
double d, d2; |
238 |
|
FVECT disp; |
239 |
|
|
245 |
|
break; |
246 |
|
case VT_PER: /* perspective view */ |
247 |
|
d = DOT(disp,v->vdir); |
248 |
+ |
if ((v->vaft > FTINY) & (d >= v->vaft)) |
249 |
+ |
rflags |= VL_BEYOND; |
250 |
|
ip[2] = VLEN(disp); |
251 |
< |
if (d < 0.0) { /* fold pyramid */ |
251 |
> |
if (d < -FTINY) { /* fold pyramid */ |
252 |
|
ip[2] = -ip[2]; |
253 |
|
d = -d; |
254 |
< |
} |
255 |
< |
if (d > FTINY) { |
256 |
< |
d = 1.0/d; |
257 |
< |
disp[0] *= d; |
258 |
< |
disp[1] *= d; |
259 |
< |
disp[2] *= d; |
260 |
< |
} |
254 |
> |
} else if (d <= FTINY) |
255 |
> |
return(VL_BAD); /* at infinite edge */ |
256 |
> |
d = 1.0/d; |
257 |
> |
disp[0] *= d; |
258 |
> |
disp[1] *= d; |
259 |
> |
disp[2] *= d; |
260 |
> |
if (ip[2] < 0.0) d = -d; |
261 |
|
ip[2] *= (1.0 - v->vfore*d); |
262 |
|
break; |
263 |
|
case VT_HEM: /* hemispherical fisheye */ |
272 |
|
d = DOT(disp,v->hvec); |
273 |
|
d2 = DOT(disp,v->vdir); |
274 |
|
ip[0] = 180.0/PI * atan2(d,d2) / v->horiz + 0.5 - v->hoff; |
275 |
< |
d = 1.0/sqrt(d*d + d2*d2); |
275 |
> |
d = d*d + d2*d2; |
276 |
> |
if (d <= FTINY*FTINY) |
277 |
> |
return(VL_BAD); /* at pole */ |
278 |
> |
if ((v->vaft > FTINY) & (d >= v->vaft*v->vaft)) |
279 |
> |
rflags |= VL_BEYOND; |
280 |
> |
d = 1.0/sqrt(d); |
281 |
|
ip[1] = DOT(disp,v->vvec)*d/v->vn2 + 0.5 - v->voff; |
282 |
|
ip[2] = VLEN(disp); |
283 |
|
ip[2] *= (1.0 - v->vfore*d); |
284 |
< |
return; |
284 |
> |
goto gotall; |
285 |
|
case VT_ANG: /* angular fisheye */ |
286 |
|
ip[0] = 0.5 - v->hoff; |
287 |
|
ip[1] = 0.5 - v->voff; |
288 |
|
ip[2] = normalize(disp) - v->vfore; |
289 |
|
d = DOT(disp,v->vdir); |
290 |
|
if (d >= 1.0-FTINY) |
291 |
< |
return; |
291 |
> |
goto gotall; |
292 |
|
if (d <= -(1.0-FTINY)) { |
293 |
|
ip[0] += 180.0/v->horiz; |
294 |
< |
return; |
294 |
> |
goto gotall; |
295 |
|
} |
296 |
|
d = (180.0/PI)*acos(d) / sqrt(1.0 - d*d); |
297 |
|
ip[0] += DOT(disp,v->hvec)*d/v->horiz; |
298 |
|
ip[1] += DOT(disp,v->vvec)*d/v->vert; |
299 |
< |
return; |
299 |
> |
goto gotall; |
300 |
|
case VT_PLS: /* planispheric fisheye */ |
301 |
|
ip[0] = 0.5 - v->hoff; |
302 |
|
ip[1] = 0.5 - v->voff; |
303 |
|
ip[2] = normalize(disp) - v->vfore; |
304 |
|
d = DOT(disp,v->vdir); |
305 |
|
if (d >= 1.0-FTINY) |
306 |
< |
return; |
306 |
> |
goto gotall; |
307 |
|
if (d <= -(1.0-FTINY)) |
308 |
< |
return; /* really an error */ |
309 |
< |
d = sqrt(1.0 - d*d) / (1.0 + d); |
310 |
< |
ip[0] += DOT(disp,v->hvec)*d/sqrt(v->hn2); |
311 |
< |
ip[1] += DOT(disp,v->vvec)*d/sqrt(v->vn2); |
312 |
< |
return; |
308 |
> |
return(VL_BAD); |
309 |
> |
ip[0] += DOT(disp,v->hvec)/((1. + d)*sqrt(v->hn2)); |
310 |
> |
ip[1] += DOT(disp,v->vvec)/((1. + d)*sqrt(v->vn2)); |
311 |
> |
goto gotall; |
312 |
> |
default: |
313 |
> |
return(VL_BAD); |
314 |
|
} |
315 |
|
ip[0] = DOT(disp,v->hvec)/v->hn2 + 0.5 - v->hoff; |
316 |
|
ip[1] = DOT(disp,v->vvec)/v->vn2 + 0.5 - v->voff; |
317 |
+ |
gotall: /* add appropriate return flags */ |
318 |
+ |
if (ip[2] <= 0.0) |
319 |
+ |
rflags |= VL_BEHIND; |
320 |
+ |
else if ((v->type != VT_PER) & (v->type != VT_CYL)) |
321 |
+ |
rflags |= VL_BEYOND*((v->vaft > FTINY) & |
322 |
+ |
(ip[2] >= v->vaft - v->vfore)); |
323 |
+ |
rflags |= VL_OUTSIDE*((0.0 >= ip[0]) | (ip[0] >= 1.0) | |
324 |
+ |
(0.0 >= ip[1]) | (ip[1] >= 1.0)); |
325 |
+ |
return(rflags); |
326 |
|
} |
327 |
|
|
328 |
|
|
334 |
|
int py |
335 |
|
) |
336 |
|
{ |
337 |
< |
register int x, y; |
337 |
> |
int x, y; |
338 |
|
|
339 |
|
if (rp->rt & YMAJOR) { |
340 |
|
x = px; |
360 |
|
double ly |
361 |
|
) |
362 |
|
{ |
363 |
< |
register int x, y; |
363 |
> |
int x, y; |
364 |
|
|
365 |
< |
x = lx * rp->xr; |
366 |
< |
y = ly * rp->yr; |
365 |
> |
x = (int)(lx*rp->xr + .5 - (lx < 0.0)); |
366 |
> |
y = (int)(ly*rp->yr + .5 - (ly < 0.0)); |
367 |
> |
|
368 |
|
if (rp->rt & XDECR) |
369 |
|
x = rp->xr-1 - x; |
370 |
|
if (rp->rt & YDECR) |
507 |
|
) |
508 |
|
{ |
509 |
|
static char vwstr[128]; |
510 |
< |
register char *cp = vwstr; |
510 |
> |
char *cp = vwstr; |
511 |
|
|
512 |
|
*cp = '\0'; |
513 |
|
if (vp->type != stdview.type) { |
566 |
|
{ |
567 |
|
static char *altname[]={NULL,VIEWSTR,"rpict","rview","rvu","rpiece","pinterp",NULL}; |
568 |
|
extern char *progname; |
569 |
< |
register char *cp; |
570 |
< |
register char **an; |
569 |
> |
char *cp; |
570 |
> |
char **an; |
571 |
|
/* add program name to list */ |
572 |
|
if (altname[0] == NULL) { |
573 |
|
for (cp = progname; *cp; cp++) |