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.4 by greg, Fri Dec 22 08:21:53 1989 UTC vs.
Revision 1.5 by greg, Mon Jan 8 14:45:52 1990 UTC

#	Line 10 | Line 10 | static char SCCSid[] = "$SunId$ LBL";
10		*     10/17/85
11		*/
12
13	–	#include  <ctype.h>
14	–
13		#include  "standard.h"
14
15		#include  "view.h"
16
17	<	VIEW  stdview = STDVIEW(512);           /* default view parameters */
17	>	VIEW  stdview = STDVIEW;                /* default view parameters */
18
19
20		char *
21	<	sskip(s)                /* skip a word */
24	<	register char  *s;
25	<	{
26	<	while (isspace(*s)) s++;
27	<	while (*s && !isspace(*s)) s++;
28	<	return(s);
29	<	}
30	<
31	<
32	<	char *
33	<	setview(v)              /* set vhinc and vvinc, return message on error */
21	>	setview(v)              /* set hvec and vvec, return message on error */
22		register VIEW  *v;
23		{
24	<	double  tan(), dt;
25	<
24	>	extern double  tan(), normalize();
25	>
26		if (normalize(v->vdir) == 0.0)          /* normalize direction */
27		return("zero view direction");
40	–
41	–	fcross(v->vhinc, v->vdir, v->vup);      /* compute horiz dir */
28
29	<	if (normalize(v->vhinc) == 0.0)
29	>	fcross(v->hvec, v->vdir, v->vup);       /* compute horiz dir */
30	>
31	>	if (normalize(v->hvec) == 0.0)
32		return("illegal view up vector");
45	–
46	–	fcross(v->vvinc, v->vhinc, v->vdir);    /* compute vert dir */
33
34	+	fcross(v->vvec, v->hvec, v->vdir);      /* compute vert dir */
35	+
36		if (v->type == VT_PAR)
37	<	dt =  v->horiz;
37	>	v->hn2 = v->horiz;
38		else if (v->type == VT_PER)
39	<	dt = 2.0 * tan(v->horiz*(PI/180.0/2.0));
39	>	v->hn2 = 2.0 * tan(v->horiz*(PI/180.0/2.0));
40		else
41		return("unknown view type");
42
43	<	if (dt <= FTINY || dt >= FHUGE)
43	>	if (v->hn2 <= FTINY || v->hn2 >= FHUGE)
44		return("illegal horizontal view size");
45
46	<	if (v->hresolu <= 0)
47	<	return("illegal horizontal resolution");
46	>	v->hvec[0] *= v->hn2;
47	>	v->hvec[1] *= v->hn2;
48	>	v->hvec[2] *= v->hn2;
49	>	v->hn2 *= v->hn2;
50
61	–	dt /= (double)v->hresolu;
62	–	v->vhinc[0] *= dt;
63	–	v->vhinc[1] *= dt;
64	–	v->vhinc[2] *= dt;
65	–
51		if (v->type == VT_PAR)
52	<	dt = v->vert;
52	>	v->vn2 = v->vert;
53		else
54	<	dt = 2.0 * tan(v->vert*(PI/180.0/2.0));
54	>	v->vn2 = 2.0 * tan(v->vert*(PI/180.0/2.0));
55
56	<	if (dt <= FTINY || dt >= FHUGE)
56	>	if (v->vn2 <= FTINY || v->vn2 >= FHUGE)
57		return("illegal vertical view size");
58
59	<	if (v->vresolu <= 0)
60	<	return("illegal vertical resolution");
61	<
62	<	dt /= (double)v->vresolu;
78	<	v->vvinc[0] *= dt;
79	<	v->vvinc[1] *= dt;
80	<	v->vvinc[2] *= dt;
59	>	v->vvec[0] *= v->vn2;
60	>	v->vvec[1] *= v->vn2;
61	>	v->vvec[2] *= v->vn2;
62	>	v->vn2 *= v->vn2;
63
82	–	v->vhn2 = DOT(v->vhinc,v->vhinc);
83	–	v->vvn2 = DOT(v->vvinc,v->vvinc);
84	–
64		return(NULL);
65		}
66
67
68	<	rayview(orig, direc, v, x, y)           /* compute ray origin and direction */
68	>	viewray(orig, direc, v, x, y)           /* compute ray origin and direction */
69		FVECT  orig, direc;
70		register VIEW  *v;
71		double  x, y;
72		{
73	<	x -= 0.5 * v->hresolu;
74	<	y -= 0.5 * v->vresolu;
73	>	x += v->hoff - 0.5;
74	>	y += v->voff - 0.5;
75
76		if (v->type == VT_PAR) {        /* parallel view */
77	<	orig[0] = v->vp[0] + x*v->vhinc[0] + y*v->vvinc[0];
78	<	orig[1] = v->vp[1] + x*v->vhinc[1] + y*v->vvinc[1];
79	<	orig[2] = v->vp[2] + x*v->vhinc[2] + y*v->vvinc[2];
77	>	orig[0] = v->vp[0] + x*v->hvec[0] + y*v->vvec[0];
78	>	orig[1] = v->vp[1] + x*v->hvec[1] + y*v->vvec[1];
79	>	orig[2] = v->vp[2] + x*v->hvec[2] + y*v->vvec[2];
80		VCOPY(direc, v->vdir);
81		} else {                        /* perspective view */
82		VCOPY(orig, v->vp);
83	<	direc[0] = v->vdir[0] + x*v->vhinc[0] + y*v->vvinc[0];
84	<	direc[1] = v->vdir[1] + x*v->vhinc[1] + y*v->vvinc[1];
85	<	direc[2] = v->vdir[2] + x*v->vhinc[2] + y*v->vvinc[2];
83	>	direc[0] = v->vdir[0] + x*v->hvec[0] + y*v->vvec[0];
84	>	direc[1] = v->vdir[1] + x*v->hvec[1] + y*v->vvec[1];
85	>	direc[2] = v->vdir[2] + x*v->hvec[2] + y*v->vvec[2];
86		normalize(direc);
87		}
88		}
89
90
91	<	pixelview(xp, yp, zp, v, p)             /* find image location for point */
91	>	viewpixel(xp, yp, zp, v, p)             /* find image location for point */
92		double  *xp, *yp, *zp;
93		register VIEW  *v;
94		FVECT  p;
#	Line 117 | Line 96 | FVECT  p;
96		extern double  sqrt();
97		double  d;
98		FVECT  disp;
99	<
99	>
100		disp[0] = p[0] - v->vp[0];
101		disp[1] = p[1] - v->vp[1];
102		disp[2] = p[2] - v->vp[2];
#	Line 136 | Line 115 | FVECT  p;
115		disp[1] *= d;
116		disp[2] *= d;
117		}
118	<	*xp = DOT(disp,v->vhinc)/v->vhn2 + 0.5*v->hresolu;
119	<	*yp = DOT(disp,v->vvinc)/v->vvn2 + 0.5*v->vresolu;
118	>	*xp = DOT(disp,v->hvec)/v->hn2 + 0.5 - v->hoff;
119	>	*yp = DOT(disp,v->vvec)/v->vn2 + 0.5 - v->voff;
120		}
121
122
123	<	sscanview(vp, s)                        /* get view parameters */
124	<	register VIEW  *vp;
123	>	int
124	>	getviewopt(v, ac, av)                   /* process view argument */
125	>	register VIEW  *v;
126	>	int  ac;
127	>	register char  *av[];
128	>	{
129	>	#define check(c,n)      if ((av[0][c]&&av[0][c]!=' ') || n>=ac) return(-1)
130	>	extern double  atof();
131	>
132	>	if (av[0][0] != '-' || av[0][1] != 'v')
133	>	return(-1);
134	>	switch (av[0][2]) {
135	>	case 't':                       /* type */
136	>	if (!av[0][3] || av[0][3]==' ')
137	>	return(-1);
138	>	check(4,0);
139	>	v->type = av[0][3];
140	>	return(0);
141	>	case 'p':                       /* point */
142	>	check(3,3);
143	>	v->vp[0] = atof(av[1]);
144	>	v->vp[1] = atof(av[2]);
145	>	v->vp[2] = atof(av[3]);
146	>	return(3);
147	>	case 'd':                       /* direction */
148	>	check(3,3);
149	>	v->vdir[0] = atof(av[1]);
150	>	v->vdir[1] = atof(av[2]);
151	>	v->vdir[2] = atof(av[3]);
152	>	return(3);
153	>	case 'u':                       /* up */
154	>	check(3,3);
155	>	v->vup[0] = atof(av[1]);
156	>	v->vup[1] = atof(av[2]);
157	>	v->vup[2] = atof(av[3]);
158	>	return(3);
159	>	case 'h':                       /* horizontal size */
160	>	check(3,1);
161	>	v->horiz = atof(av[1]);
162	>	return(1);
163	>	case 'v':                       /* vertical size */
164	>	check(3,1);
165	>	v->vert = atof(av[1]);
166	>	return(1);
167	>	case 's':                       /* shift */
168	>	check(3,1);
169	>	v->hoff = atof(av[1]);
170	>	return(1);
171	>	case 'l':                       /* lift */
172	>	check(3,1);
173	>	v->voff = atof(av[1]);
174	>	return(1);
175	>	default:
176	>	return(-1);
177	>	}
178	>	#undef check
179	>	}
180	>
181	>
182	>	int
183	>	sscanview(vp, s)                        /* get view parameters from string */
184	>	VIEW  *vp;
185		register char  *s;
186		{
187	<	for ( ; ; )
188	<	switch (*s++) {
189	<	case '\0':
190	<	case '\n':
191	<	return(0);
192	<	case '-':
193	<	switch (*s++) {
194	<	case '\0':
195	<	return(-1);
196	<	case 'x':
197	<	if (sscanf(s, "%d", &vp->hresolu) != 1)
198	<	return(-1);
199	<	s = sskip(s);
200	<	continue;
201	<	case 'y':
202	<	if (sscanf(s, "%d", &vp->vresolu) != 1)
203	<	return(-1);
204	<	s = sskip(s);
205	<	continue;
206	<	case 'v':
168	<	switch (*s++) {
169	<	case '\0':
170	<	return(-1);
171	<	case 't':
172	<	vp->type = *s++;
173	<	continue;
174	<	case 'p':
175	<	if (sscanf(s, "%lf %lf %lf",
176	<	&vp->vp[0],
177	<	&vp->vp[1],
178	<	&vp->vp[2]) != 3)
179	<	return(-1);
180	<	s = sskip(sskip(sskip(s)));
181	<	continue;
182	<	case 'd':
183	<	if (sscanf(s, "%lf %lf %lf",
184	<	&vp->vdir[0],
185	<	&vp->vdir[1],
186	<	&vp->vdir[2]) != 3)
187	<	return(-1);
188	<	s = sskip(sskip(sskip(s)));
189	<	continue;
190	<	case 'u':
191	<	if (sscanf(s, "%lf %lf %lf",
192	<	&vp->vup[0],
193	<	&vp->vup[1],
194	<	&vp->vup[2]) != 3)
195	<	return(-1);
196	<	s = sskip(sskip(sskip(s)));
197	<	continue;
198	<	case 'h':
199	<	if (sscanf(s, "%lf",
200	<	&vp->horiz) != 1)
201	<	return(-1);
202	<	s = sskip(s);
203	<	continue;
204	<	case 'v':
205	<	if (sscanf(s, "%lf",
206	<	&vp->vert) != 1)
207	<	return(-1);
208	<	s = sskip(s);
209	<	continue;
210	<	}
211	<	continue;
212	<	}
213	<	continue;
187	>	int  ac;
188	>	char  *av[4];
189	>	int  na;
190	>	int  nvopts = 0;
191	>
192	>	while (*s == ' ')
193	>	s++;
194	>	do {
195	>	ac = 0;
196	>	do {
197	>	av[ac++] = s;
198	>	while (*s && *s != ' ')
199	>	s++;
200	>	while (*s == ' ')
201	>	s++;
202	>	} while (*s && ac < 4);
203	>	if ((na = getviewopt(vp, ac, av)) >= 0) {
204	>	if (na+1 < ac)
205	>	s = av[na+1];
206	>	nvopts++;
207		}
208	+	} while (*s);
209	+	return(nvopts);
210		}
211
212
#	Line 224 | Line 219 | FILE  *fp;
219		fprintf(fp, " -vd %.6g %.6g %.6g", vp->vdir[0], vp->vdir[1], vp->vdir[2]);
220		fprintf(fp, " -vu %.6g %.6g %.6g", vp->vup[0], vp->vup[1], vp->vup[2]);
221		fprintf(fp, " -vh %.6g -vv %.6g", vp->horiz, vp->vert);
222	<	fprintf(fp, " -x %d -y %d", vp->hresolu, vp->vresolu);
222	>	fprintf(fp, " -vs %d -vl %d", vp->hoff, vp->voff);
223		}
224
225
#	Line 241 | Line 236 | char  *s;
236
237		for (an = altname; *an != NULL; an++)
238		if (!strncmp(*an, s, strlen(*an))) {
239	<	if (sscanview(hview, s+strlen(*an)) == 0)
239	>	if (sscanview(hview, s+strlen(*an)) > 0)
240		gothview++;
241		return;
242		}

Diff Legend

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