ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/common/image.c

Comparing ray/src/common/image.c (file contents):
Revision 2.35 by greg, Fri Dec 12 22:05:38 2008 UTC vs.
Revision 2.48 by greg, Fri Apr 27 18:09:26 2018 UTC

#	Line 33 | Line 33 | VIEW  *v
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)
#	Line 169 | Line 170 | double  y
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 */
#	Line 182 | Line 181 | double  y
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);
#	Line 193 | Line 190 | double  y
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 */
#	Line 212 | Line 207 | double  y
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
#	Line 254 | Line 245 | FVECT  p
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 */
#	Line 279 | Line 272 | FVECT  p
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
#	Line 326 | Line 334 | int  px,
334		int  py
335		)
336		{
337	<	register int  x, y;
337	>	int  x, y;
338
339		if (rp->rt & YMAJOR) {
340		x = px;
#	Line 352 | Line 360 | double  lx,
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)
#	Line 498 | Line 507 | VIEW  *vp
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) {
#	Line 557 | Line 566 | char  *s
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++)

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)