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 1.17 by greg, Mon Nov 11 14:00:14 1991 UTC vs.
Revision 2.8 by greg, Wed Dec 21 09:07:19 1994 UTC

#	Line 1 | Line 1
1	<	/* Copyright (c) 1991 Regents of the University of California */
1	>	/* Copyright (c) 1994 Regents of the University of California */
2
3		#ifndef lint
4		static char SCCSid[] = "$SunId$ LBL";
#	Line 16 | Line 16 | static char SCCSid[] = "$SunId$ LBL";
16
17		#include  "resolu.h"
18
19	+	#include  "paths.h"
20	+
21		VIEW  stdview = STDVIEW;                /* default view parameters */
22
23
#	Line 26 | Line 28 | register VIEW  *v;
28		static char  ill_horiz[] = "illegal horizontal view size";
29		static char  ill_vert[] = "illegal vertical view size";
30
31	+	if (v->vfore < -FTINY || v->vaft < -FTINY ||
32	+	(v->vaft > FTINY && v->vaft <= v->vfore))
33	+	return("illegal fore/aft clipping plane");
34	+
35		if (normalize(v->vdir) == 0.0)          /* normalize direction */
36		return("zero view direction");
37
#	Line 105 | Line 111 | int  *xp, *yp;                 /* x and y resolution in (or out if *
111		}
112
113
114	+	double
115		viewray(orig, direc, v, x, y)           /* compute ray origin and direction */
116		FVECT  orig, direc;
117		register VIEW  *v;
#	Line 117 | Line 124 | double  x, y;
124
125		switch(v->type) {
126		case VT_PAR:                    /* parallel view */
127	<	orig[0] = v->vp[0] + x*v->hvec[0] + y*v->vvec[0];
128	<	orig[1] = v->vp[1] + x*v->hvec[1] + y*v->vvec[1];
129	<	orig[2] = v->vp[2] + x*v->hvec[2] + y*v->vvec[2];
127	>	orig[0] = v->vp[0] + v->vfore*v->vdir[0]
128	>	+ x*v->hvec[0] + y*v->vvec[0];
129	>	orig[1] = v->vp[1] + v->vfore*v->vdir[1]
130	>	+ x*v->hvec[1] + y*v->vvec[1];
131	>	orig[2] = v->vp[2] + v->vfore*v->vdir[2]
132	>	+ x*v->hvec[2] + y*v->vvec[2];
133		VCOPY(direc, v->vdir);
134	<	return(0);
134	>	return(v->vaft > FTINY ? v->vaft - v->vfore : 0.0);
135		case VT_PER:                    /* perspective view */
126	–	VCOPY(orig, v->vp);
136		direc[0] = v->vdir[0] + x*v->hvec[0] + y*v->vvec[0];
137		direc[1] = v->vdir[1] + x*v->hvec[1] + y*v->vvec[1];
138		direc[2] = v->vdir[2] + x*v->hvec[2] + y*v->vvec[2];
139	<	normalize(direc);
140	<	return(0);
139	>	orig[0] = v->vp[0] + v->vfore*direc[0];
140	>	orig[1] = v->vp[1] + v->vfore*direc[1];
141	>	orig[2] = v->vp[2] + v->vfore*direc[2];
142	>	d = normalize(direc);
143	>	return(v->vaft > FTINY ? (v->vaft - v->vfore)*d : 0.0);
144		case VT_HEM:                    /* hemispherical fisheye */
145		z = 1.0 - x*x*v->hn2 - y*y*v->vn2;
146		if (z < 0.0)
147	<	return(-1);
147	>	return(-1.0);
148		z = sqrt(z);
137	–	VCOPY(orig, v->vp);
149		direc[0] = z*v->vdir[0] + x*v->hvec[0] + y*v->vvec[0];
150		direc[1] = z*v->vdir[1] + x*v->hvec[1] + y*v->vvec[1];
151		direc[2] = z*v->vdir[2] + x*v->hvec[2] + y*v->vvec[2];
152	<	return(0);
152	>	orig[0] = v->vp[0] + v->vfore*direc[0];
153	>	orig[1] = v->vp[1] + v->vfore*direc[1];
154	>	orig[2] = v->vp[2] + v->vfore*direc[2];
155	>	return(v->vaft > FTINY ? v->vaft - v->vfore : 0.0);
156		case VT_ANG:                    /* angular fisheye */
157		x *= v->horiz/180.0;
158		y *= v->vert/180.0;
159		d = x*x + y*y;
160		if (d > 1.0)
161	<	return(-1);
148	<	VCOPY(orig, v->vp);
149	<	if (d <= FTINY) {
150	<	VCOPY(direc, v->vdir);
151	<	return(0);
152	<	}
161	>	return(-1.0);
162		d = sqrt(d);
163		z = cos(PI*d);
164	<	d = sqrt(1 - z*z)/d;
164	>	d = d <= FTINY ? PI : sqrt(1 - z*z)/d;
165		x *= d;
166		y *= d;
167		direc[0] = z*v->vdir[0] + x*v->hvec[0] + y*v->vvec[0];
168		direc[1] = z*v->vdir[1] + x*v->hvec[1] + y*v->vvec[1];
169		direc[2] = z*v->vdir[2] + x*v->hvec[2] + y*v->vvec[2];
170	<	return(0);
170	>	orig[0] = v->vp[0] + v->vfore*direc[0];
171	>	orig[1] = v->vp[1] + v->vfore*direc[1];
172	>	orig[2] = v->vp[2] + v->vfore*direc[2];
173	>	return(v->vaft > FTINY ? v->vaft - v->vfore : 0.0);
174		}
175	<	return(-1);
175	>	return(-1.0);
176		}
177
178
#	Line 178 | Line 190 | FVECT  p;
190
191		switch (v->type) {
192		case VT_PAR:                    /* parallel view */
193	<	ip[2] = DOT(disp,v->vdir);
193	>	ip[2] = DOT(disp,v->vdir) - v->vfore;
194		break;
195		case VT_PER:                    /* perspective view */
196		d = DOT(disp,v->vdir);
#	Line 186 | Line 198 | FVECT  p;
198		if (d < 0.0) {          /* fold pyramid */
199		ip[2] = -ip[2];
200		d = -d;
201	<	} else if (d > FTINY) {
201	>	}
202	>	if (d > FTINY) {
203		d = 1.0/d;
204		disp[0] *= d;
205		disp[1] *= d;
206		disp[2] *= d;
207		}
208	+	ip[2] *= (1.0 - v->vfore*d);
209		break;
210		case VT_HEM:                    /* hemispherical fisheye */
211		d = normalize(disp);
#	Line 199 | Line 213 | FVECT  p;
213		ip[2] = -d;
214		else
215		ip[2] = d;
216	+	ip[2] -= v->vfore;
217		break;
218		case VT_ANG:                    /* angular fisheye */
219		ip[0] = 0.5 - v->hoff;
220		ip[1] = 0.5 - v->voff;
221	<	ip[2] = normalize(disp);
221	>	ip[2] = normalize(disp) - v->vfore;
222		d = DOT(disp,v->vdir);
223		if (d >= 1.0-FTINY)
224		return;
225		if (d <= -(1.0-FTINY)) {
226	<	ip[1] += 180.0/v->horiz;
227	<	ip[2] += 180.0/v->vert;
226	>	ip[0] += 180.0/v->horiz;
227	>	ip[1] += 180.0/v->vert;
228		return;
229		}
230		d = acos(d)/PI / sqrt(1.0 - d*d);
#	Line 276 | Line 291 | register char  *av[];
291		{
292		#define check(c,l)      if ((av[0][c]&&av[0][c]!=' ') || \
293		badarg(ac-1,av+1,l)) return(-1)
279	–	extern double  atof();
294
295		if (ac <= 0 || av[0][0] != '-' || av[0][1] != 'v')
296		return(-1);
#	Line 313 | Line 327 | register char  *av[];
327		check(3,"f");
328		v->vert = atof(av[1]);
329		return(1);
330	+	case 'o':                       /* fore clipping plane */
331	+	check(3,"f");
332	+	v->vfore = atof(av[1]);
333	+	return(1);
334	+	case 'a':                       /* aft clipping plane */
335	+	check(3,"f");
336	+	v->vaft = atof(av[1]);
337	+	return(1);
338		case 's':                       /* shift */
339		check(3,"f");
340		v->hoff = atof(av[1]);
#	Line 338 | Line 360 | register char  *s;
360		int  na;
361		int  nvopts = 0;
362
363	<	while (*s == ' ')
364	<	s++;
363	>	if (*s != '-')
364	>	s = sskip(s);
365		while (*s) {
366		ac = 0;
367		do {
#	Line 369 | Line 391 | FILE  *fp;
391		fprintf(fp, " -vd %.6g %.6g %.6g", vp->vdir[0], vp->vdir[1], vp->vdir[2]);
392		fprintf(fp, " -vu %.6g %.6g %.6g", vp->vup[0], vp->vup[1], vp->vup[2]);
393		fprintf(fp, " -vh %.6g -vv %.6g", vp->horiz, vp->vert);
394	+	fprintf(fp, " -vo %.6g -va %.6g", vp->vfore, vp->vaft);
395		fprintf(fp, " -vs %.6g -vl %.6g", vp->hoff, vp->voff);
396		}
397
398
399	<	static char  *altname[] = {NULL,"rpict","rview","pinterp",VIEWSTR,NULL};
399	>	int
400	>	isview(s)                               /* is this a view string? */
401	>	char  *s;
402	>	{
403	>	static char  *altname[]={NULL,VIEWSTR,"rpict","rview","pinterp",NULL};
404	>	extern char  *progname;
405	>	register char  *cp;
406	>	register char  **an;
407	>	/* add program name to list */
408	>	if (altname[0] == NULL) {
409	>	for (cp = progname; *cp; cp++)
410	>	;
411	>	while (cp > progname && !ISDIRSEP(cp[-1]))
412	>	cp--;
413	>	altname[0] = cp;
414	>	}
415	>	/* skip leading path */
416	>	cp = s;
417	>	while (*cp && *cp != ' ')
418	>	cp++;
419	>	while (cp > s && !ISDIRSEP(cp[-1]))
420	>	cp--;
421	>	for (an = altname; *an != NULL; an++)
422	>	if (!strncmp(*an, cp, strlen(*an)))
423	>	return(1);
424	>	return(0);
425	>	}
426
427	+
428		struct myview {
429		VIEW    *hv;
430		int     ok;
#	Line 386 | Line 436 | gethview(s, v)                         /* get view from header */
436		char  *s;
437		register struct myview  *v;
438		{
439	<	register char  **an;
440	<
391	<	for (an = altname; *an != NULL; an++)
392	<	if (!strncmp(*an, s, strlen(*an))) {
393	<	if (sscanview(v->hv, s+strlen(*an)) > 0)
394	<	v->ok++;
395	<	return;
396	<	}
439	>	if (isview(s) && sscanview(v->hv, s) > 0)
440	>	v->ok++;
441		}
442
443
#	Line 403 | Line 447 | char  *fname;
447		VIEW  *vp;
448		RESOLU  *rp;
449		{
406	–	extern char  *progname;
450		struct myview   mvs;
451		FILE  *fp;
452
453		if ((fp = fopen(fname, "r")) == NULL)
454		return(-1);
455
413	–	altname[0] = progname;
456		mvs.hv = vp;
457		mvs.ok = 0;
458

Diff Legend

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