src/rt/rv3.c

/* Copyright (c) 1987 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 *  rv3.c - miscellaneous routines for rview.
 *
 *     5/11/87
 */

#include  "ray.h"

#include  "octree.h"

#include  "rpaint.h"

#include  "random.h"

#ifndef WFLUSH
#define WFLUSH          30              /* flush after this many rays */
#endif


getrect(s, r)                           /* get a box */
char  *s;
register RECT  *r;
{
        int  x0, y0, x1, y1;

        if (*s && !strncmp(s, "all", strlen(s))) {
                r->l = r->d = 0;
                r->r = hresolu;
                r->u = vresolu;
                return(0);
        }
        if (sscanf(s, "%d %d %d %d", &x0, &y0, &x1, &y1) != 4) {
                if (dev->getcur == NULL)
                        return(-1);
                (*dev->comout)("Pick first corner\n");
                if ((*dev->getcur)(&x0, &y0) == ABORT)
                        return(-1);
                (*dev->comout)("Pick second corner\n");
                if ((*dev->getcur)(&x1, &y1) == ABORT)
                        return(-1);
        }
        if (x0 < x1) {
                r->l = x0;
                r->r = x1;
        } else {
                r->l = x1;
                r->r = x0;
        }
        if (y0 < y1) {
                r->d = y0;
                r->u = y1;
        } else {
                r->d = y1;
                r->u = y0;
        }
        if (r->l < 0) r->l = 0;
        if (r->d < 0) r->d = 0;
        if (r->r > hresolu) r->r = hresolu;
        if (r->u > vresolu) r->u = vresolu;
        if (r->l > r->r) r->l = r->r;
        if (r->d > r->u) r->d = r->u;
        return(0);
}


getinterest(s, direc, vec, mp)          /* get area of interest */
char  *s;
int  direc;
FVECT  vec;
double  *mp;
{
        int  x, y;
        RAY  thisray;
        register int  i;

        if (sscanf(s, "%lf", mp) != 1)
                *mp = 1.0;
        else if (*mp < -FTINY)          /* negative zoom is reduction */
                *mp = -1.0 / *mp;
        else if (*mp <= FTINY) {        /* too small */
                error(COMMAND, "illegal magnification");
                return(-1);
        }
        if (sscanf(s, "%*lf %lf %lf %lf", &vec[0], &vec[1], &vec[2]) != 3) {
                if (dev->getcur == NULL)
                        return(-1);
                (*dev->comout)("Pick view center\n");
                if ((*dev->getcur)(&x, &y) == ABORT)
                        return(-1);
                if (viewray(thisray.rorg, thisray.rdir, &ourview,
                                (x+.5)/hresolu, (y+.5)/vresolu) < 0) {
                        error(COMMAND, "not on image");
                        return(-1);
                }
                if (!direc || ourview.type == VT_PAR) {
                        rayorigin(&thisray, NULL, PRIMARY, 1.0);
                        if (!localhit(&thisray, &thescene)) {
                                error(COMMAND, "not a local object");
                                return(-1);
                        }
                }
                if (direc)
                        if (ourview.type == VT_PAR)
                                for (i = 0; i < 3; i++)
                                        vec[i] = thisray.rop[i] - ourview.vp[i];
                        else
                                VCOPY(vec, thisray.rdir);
                else
                        VCOPY(vec, thisray.rop);
        } else if (direc)
                        for (i = 0; i < 3; i++)
                                vec[i] -= ourview.vp[i];
        return(0);
}


float *         /* keep consistent with COLOR typedef */
greyof(col)                             /* convert color to greyscale */
register COLOR  col;
{
        static COLOR  gcol;
        double  b;

        b = bright(col);
        setcolor(gcol, b, b, b);
        return(gcol);
}


paint(p, xmin, ymin, xmax, ymax)        /* compute and paint a rectangle */
register PNODE  *p;
int  xmin, ymin, xmax, ymax;
{
        extern long  nrays;
        static long  lastflush = 0;
        static RAY  thisray;
        double  h, v;

        if (xmax - xmin <= 0 || ymax - ymin <= 0) {     /* empty */
                p->x = xmin;
                p->y = ymin;
                setcolor(p->v, 0.0, 0.0, 0.0);
                return;
        }
                                                /* jitter ray direction */
        h = xmin + (xmax-xmin)*frandom();
        v = ymin + (ymax-ymin)*frandom();
        
        if (viewray(thisray.rorg, thisray.rdir, &ourview,
                        h/hresolu, v/vresolu) < 0) {
                setcolor(thisray.rcol, 0.0, 0.0, 0.0);
        } else {
                rayorigin(&thisray, NULL, PRIMARY, 1.0);
                samplendx++;
                rayvalue(&thisray);
        }

        p->x = h;
        p->y = v;
        copycolor(p->v, thisray.rcol);
        scalecolor(p->v, exposure);

        (*dev->paintr)(greyscale?greyof(p->v):p->v, xmin, ymin, xmax, ymax);

        if (dev->flush != NULL && nrays - lastflush >= WFLUSH) {
                lastflush = nrays;
                (*dev->flush)();
        }
}


newimage()                              /* start a new image */
{
                                                /* free old image */
        freepkids(&ptrunk);
                                                /* save reserve memory */
        fillreserves();
                                                /* compute resolution */
        hresolu = dev->xsiz;
        vresolu = dev->ysiz;
        normaspect(viewaspect(&ourview), &dev->pixaspect, &hresolu, &vresolu);
        pframe.l = pframe.d = 0;
        pframe.r = hresolu; pframe.u = vresolu;
        pdepth = 0;
                                                /* clear device */
        (*dev->clear)(hresolu, vresolu);
                                                /* get first value */
        paint(&ptrunk, 0, 0, hresolu, vresolu);
}


redraw()                                /* redraw the image */
{
        (*dev->clear)(hresolu, vresolu);
        (*dev->comout)("redrawing...\n");
        repaint(0, 0, hresolu, vresolu);
        (*dev->comout)("\n");
}


repaint(xmin, ymin, xmax, ymax)                 /* repaint a region */
int  xmin, ymin, xmax, ymax;
{
        RECT  reg;

        reg.l = xmin; reg.r = xmax;
        reg.d = ymin; reg.u = ymax;

        paintrect(&ptrunk, 0, 0, hresolu, vresolu, &reg);
}


paintrect(p, xmin, ymin, xmax, ymax, r)         /* paint picture rectangle */
register PNODE  *p;
int  xmin, ymin, xmax, ymax;
register RECT  *r;
{
        int  mx, my;

        if (xmax - xmin <= 0 || ymax - ymin <= 0)
                return;

        if (p->kid == NULL) {
                (*dev->paintr)(greyscale?greyof(p->v):p->v,
                                xmin, ymin, xmax, ymax);        /* do this */
                return;
        }
        mx = (xmin + xmax) >> 1;                                /* do kids */
        my = (ymin + ymax) >> 1;
        if (mx > r->l) {
                if (my > r->d)
                        paintrect(p->kid+DL, xmin, ymin, mx, my, r);
                if (my < r->u)
                        paintrect(p->kid+UL, xmin, my, mx, ymax, r);
        }
        if (mx < r->r) {
                if (my > r->d)
                        paintrect(p->kid+DR, mx, ymin, xmax, my, r);
                if (my < r->u)
                        paintrect(p->kid+UR, mx, my, xmax, ymax, r);
        }
}


PNODE *
findrect(x, y, p, r, pd)                /* find a rectangle */
int  x, y;
register PNODE  *p;
register RECT  *r;
int  pd;
{
        int  mx, my;

        while (p->kid != NULL && pd--) {

                mx = (r->l + r->r) >> 1;
                my = (r->d + r->u) >> 1;

                if (x < mx) {
                        r->r = mx;
                        if (y < my) {
                                r->u = my;
                                p = p->kid+DL;
                        } else {
                                r->d = my;
                                p = p->kid+UL;
                        }
                } else {
                        r->l = mx;
                        if (y < my) {
                                r->u = my;
                                p = p->kid+DR;
                        } else {
                                r->d = my;
                                p = p->kid+UR;
                        }
                }
        }
        return(p);
}


scalepict(p, sf)                        /* scale picture values */
register PNODE  *p;
double  sf;
{
        scalecolor(p->v, sf);           /* do this node */

        if (p->kid == NULL)
                return;
                                        /* do children */
        scalepict(p->kid+DL, sf);
        scalepict(p->kid+DR, sf);
        scalepict(p->kid+UL, sf);
        scalepict(p->kid+UR, sf);
}


getpictcolrs(yoff, scan, p, xsiz, ysiz) /* get scanline from picture */
int  yoff;
register COLR  *scan;
register PNODE  *p;
int  xsiz, ysiz;
{
        register int  mx;
        int  my;

        if (p->kid == NULL) {                   /* do this node */
                setcolr(scan[0], colval(p->v,RED),
                                colval(p->v,GRN),
                                colval(p->v,BLU));
                for (mx = 1; mx < xsiz; mx++)
                        copycolr(scan[mx], scan[0]);
                return;
        }
                                                /* do kids */
        mx = xsiz >> 1;
        my = ysiz >> 1;
        if (yoff < my) {
                getpictcolrs(yoff, scan, p->kid+DL, mx, my);
                getpictcolrs(yoff, scan+mx, p->kid+DR, xsiz-mx, my);
        } else {
                getpictcolrs(yoff-my, scan, p->kid+UL, mx, ysiz-my);
                getpictcolrs(yoff-my, scan+mx, p->kid+UR, xsiz-mx, ysiz-my);
        }
}


pcopy(p1, p2)                           /* copy paint node p1 into p2 */
register PNODE  *p1, *p2;
{
        copycolor(p2->v, p1->v);
        p2->x = p1->x;
        p2->y = p1->y;
}


freepkids(p)                            /* free pnode's children */
register PNODE  *p;
{
        if (p->kid == NULL)
                return;
        freepkids(p->kid+DL);
        freepkids(p->kid+DR);
        freepkids(p->kid+UL);
        freepkids(p->kid+UR);
        free((char *)p->kid);
        p->kid = NULL;
}


newview(vp)                             /* change viewing parameters */
register VIEW  *vp;
{
        char  *err;

        if ((err = setview(vp)) != NULL) {
                sprintf(errmsg, "view not set - %s", err);
                error(COMMAND, errmsg);
        } else if (bcmp((char *)vp, (char *)&ourview, sizeof(VIEW))) {
                copystruct(&oldview, &ourview);
                copystruct(&ourview, vp);
                newimage();
        }
}


moveview(angle, elev, mag, vc)                  /* move viewpoint */
double  angle, elev, mag;
FVECT  vc;
{
        extern double  sqrt(), dist2();
        double  d;
        FVECT  v1;
        VIEW  nv;
        register int  i;

        VCOPY(nv.vup, ourview.vup);
        nv.hoff = ourview.hoff; nv.voff = ourview.voff;
        spinvector(nv.vdir, ourview.vdir, ourview.vup, angle*(PI/180.));
        if (elev != 0.0) {
                fcross(v1, ourview.vup, nv.vdir);
                normalize(v1);
                spinvector(nv.vdir, nv.vdir, v1, elev*(PI/180.));
        }
        if ((nv.type = ourview.type) == VT_PAR) {
                nv.horiz = ourview.horiz / mag;
                nv.vert = ourview.vert / mag;
                d = 0.0;                        /* don't move closer */
                for (i = 0; i < 3; i++)
                        d += (vc[i] - ourview.vp[i])*ourview.vdir[i];
        } else {
                nv.horiz = ourview.horiz;
                nv.vert = ourview.vert;
                d = sqrt(dist2(ourview.vp, vc)) / mag;
        }
        for (i = 0; i < 3; i++)
                nv.vp[i] = vc[i] - d*nv.vdir[i];
        newview(&nv);
}


zoomview(vp, zf)                        /* zoom in our out */
register VIEW  *vp;
double  zf;
{
        switch (vp->type) {
        case VT_PAR:                            /* parallel view */
        case VT_ANG:                            /* angular fisheye */
                vp->horiz /= zf;
                vp->vert /= zf;
                return;
        case VT_PER:                            /* perspective view */
                vp->horiz = atan(tan(vp->horiz*(PI/180./2.))/zf) /
                                (PI/180./2.);
                vp->vert = atan(tan(vp->vert*(PI/180./2.))/zf) /
                                (PI/180./2.);
                return;
        case VT_HEM:                            /* hemispherical fisheye */
                vp->horiz = sin(vp->horiz*(PI/180./2.))/zf;
                if (vp->horiz >= 1.0-FTINY)
                        vp->horiz = 180.;
                else
                        vp->horiz = asin(vp->horiz) / (PI/180./2.);
                vp->vert = sin(vp->vert*(PI/180./2.))/zf;
                if (vp->vert >= 1.0-FTINY)
                        vp->vert = 180.;
                else
                        vp->vert = asin(vp->vert) / (PI/180./2.);
                return;
        }
}
Revision:	2.1
Committed:	Tue Nov 12 17:09:47 1991 UTC (32 years, 5 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.20:	+0 -0 lines
Log Message:	updated revision number for release 2.0
#	User	Rev	Content
1	greg	1.1	/* Copyright (c) 1987 Regents of the University of California */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* rv3.c - miscellaneous routines for rview.
9			*
10			* 5/11/87
11			*/
12
13			#include "ray.h"
14
15	greg	1.7	#include "octree.h"
16
17	greg	1.1	#include "rpaint.h"
18
19			#include "random.h"
20	greg	1.7
21	greg	1.13	#ifndef WFLUSH
22			#define WFLUSH 30 /* flush after this many rays */
23			#endif
24	greg	1.7
25	greg	1.13
26	greg	1.7	getrect(s, r) /* get a box */
27			char *s;
28			register RECT *r;
29			{
30			int x0, y0, x1, y1;
31
32			if (*s && !strncmp(s, "all", strlen(s))) {
33			r->l = r->d = 0;
34	greg	1.9	r->r = hresolu;
35			r->u = vresolu;
36	greg	1.7	return(0);
37			}
38			if (sscanf(s, "%d %d %d %d", &x0, &y0, &x1, &y1) != 4) {
39			if (dev->getcur == NULL)
40			return(-1);
41			(*dev->comout)("Pick first corner\n");
42			if ((*dev->getcur)(&x0, &y0) == ABORT)
43			return(-1);
44			(*dev->comout)("Pick second corner\n");
45			if ((*dev->getcur)(&x1, &y1) == ABORT)
46			return(-1);
47			}
48			if (x0 < x1) {
49			r->l = x0;
50			r->r = x1;
51			} else {
52			r->l = x1;
53			r->r = x0;
54			}
55			if (y0 < y1) {
56			r->d = y0;
57			r->u = y1;
58			} else {
59			r->d = y1;
60			r->u = y0;
61			}
62			if (r->l < 0) r->l = 0;
63			if (r->d < 0) r->d = 0;
64	greg	1.9	if (r->r > hresolu) r->r = hresolu;
65			if (r->u > vresolu) r->u = vresolu;
66	greg	1.7	if (r->l > r->r) r->l = r->r;
67			if (r->d > r->u) r->d = r->u;
68			return(0);
69			}
70
71
72			getinterest(s, direc, vec, mp) /* get area of interest */
73			char *s;
74			int direc;
75			FVECT vec;
76			double *mp;
77			{
78			int x, y;
79			RAY thisray;
80			register int i;
81
82			if (sscanf(s, "%lf", mp) != 1)
83			*mp = 1.0;
84			else if (mp < -FTINY) / negative zoom is reduction */
85			mp = -1.0 / mp;
86			else if (mp <= FTINY) { / too small */
87			error(COMMAND, "illegal magnification");
88			return(-1);
89			}
90			if (sscanf(s, "%*lf %lf %lf %lf", &vec[0], &vec[1], &vec[2]) != 3) {
91			if (dev->getcur == NULL)
92			return(-1);
93			(*dev->comout)("Pick view center\n");
94			if ((*dev->getcur)(&x, &y) == ABORT)
95			return(-1);
96	greg	1.17	if (viewray(thisray.rorg, thisray.rdir, &ourview,
97			(x+.5)/hresolu, (y+.5)/vresolu) < 0) {
98			error(COMMAND, "not on image");
99			return(-1);
100			}
101	greg	1.7	if (!direc \|\| ourview.type == VT_PAR) {
102			rayorigin(&thisray, NULL, PRIMARY, 1.0);
103			if (!localhit(&thisray, &thescene)) {
104			error(COMMAND, "not a local object");
105			return(-1);
106			}
107			}
108			if (direc)
109			if (ourview.type == VT_PAR)
110			for (i = 0; i < 3; i++)
111			vec[i] = thisray.rop[i] - ourview.vp[i];
112			else
113			VCOPY(vec, thisray.rdir);
114			else
115			VCOPY(vec, thisray.rop);
116			} else if (direc)
117			for (i = 0; i < 3; i++)
118			vec[i] -= ourview.vp[i];
119			return(0);
120			}
121	greg	1.1
122
123			float * /* keep consistent with COLOR typedef */
124			greyof(col) /* convert color to greyscale */
125			register COLOR col;
126			{
127			static COLOR gcol;
128			double b;
129
130			b = bright(col);
131			setcolor(gcol, b, b, b);
132			return(gcol);
133			}
134
135
136			paint(p, xmin, ymin, xmax, ymax) /* compute and paint a rectangle */
137			register PNODE *p;
138			int xmin, ymin, xmax, ymax;
139			{
140	greg	1.13	extern long nrays;
141			static long lastflush = 0;
142	greg	1.1	static RAY thisray;
143			double h, v;
144
145			if (xmax - xmin <= 0 \|\| ymax - ymin <= 0) { /* empty */
146			p->x = xmin;
147			p->y = ymin;
148			setcolor(p->v, 0.0, 0.0, 0.0);
149			return;
150			}
151			/* jitter ray direction */
152	greg	1.15	h = xmin + (xmax-xmin)*frandom();
153			v = ymin + (ymax-ymin)*frandom();
154	greg	1.1
155	greg	1.17	if (viewray(thisray.rorg, thisray.rdir, &ourview,
156			h/hresolu, v/vresolu) < 0) {
157			setcolor(thisray.rcol, 0.0, 0.0, 0.0);
158			} else {
159			rayorigin(&thisray, NULL, PRIMARY, 1.0);
160	greg	1.20	samplendx++;
161	greg	1.17	rayvalue(&thisray);
162			}
163	greg	1.1
164	greg	1.15	p->x = h;
165			p->y = v;
166	greg	1.1	copycolor(p->v, thisray.rcol);
167			scalecolor(p->v, exposure);
168
169			(*dev->paintr)(greyscale?greyof(p->v):p->v, xmin, ymin, xmax, ymax);
170	greg	1.13
171			if (dev->flush != NULL && nrays - lastflush >= WFLUSH) {
172			lastflush = nrays;
173			(*dev->flush)();
174			}
175	greg	1.1	}
176
177
178			newimage() /* start a new image */
179			{
180			/* free old image */
181			freepkids(&ptrunk);
182	greg	1.19	/* save reserve memory */
183			fillreserves();
184	greg	1.9	/* compute resolution */
185	greg	1.10	hresolu = dev->xsiz;
186			vresolu = dev->ysiz;
187	greg	1.11	normaspect(viewaspect(&ourview), &dev->pixaspect, &hresolu, &vresolu);
188	greg	1.1	pframe.l = pframe.d = 0;
189	greg	1.9	pframe.r = hresolu; pframe.u = vresolu;
190	greg	1.1	pdepth = 0;
191			/* clear device */
192	greg	1.9	(*dev->clear)(hresolu, vresolu);
193	greg	1.1	/* get first value */
194	greg	1.9	paint(&ptrunk, 0, 0, hresolu, vresolu);
195	greg	1.1	}
196
197
198			redraw() /* redraw the image */
199			{
200	greg	1.9	(*dev->clear)(hresolu, vresolu);
201	greg	1.1	(*dev->comout)("redrawing...\n");
202	greg	1.9	repaint(0, 0, hresolu, vresolu);
203	greg	1.1	(*dev->comout)("\n");
204			}
205
206
207			repaint(xmin, ymin, xmax, ymax) /* repaint a region */
208			int xmin, ymin, xmax, ymax;
209			{
210			RECT reg;
211
212			reg.l = xmin; reg.r = xmax;
213			reg.d = ymin; reg.u = ymax;
214
215	greg	1.9	paintrect(&ptrunk, 0, 0, hresolu, vresolu, &reg);
216	greg	1.1	}
217
218
219			paintrect(p, xmin, ymin, xmax, ymax, r) /* paint picture rectangle */
220			register PNODE *p;
221			int xmin, ymin, xmax, ymax;
222			register RECT *r;
223			{
224			int mx, my;
225
226			if (xmax - xmin <= 0 \|\| ymax - ymin <= 0)
227			return;
228
229			if (p->kid == NULL) {
230			(*dev->paintr)(greyscale?greyof(p->v):p->v,
231			xmin, ymin, xmax, ymax); /* do this */
232			return;
233			}
234			mx = (xmin + xmax) >> 1; /* do kids */
235			my = (ymin + ymax) >> 1;
236			if (mx > r->l) {
237			if (my > r->d)
238			paintrect(p->kid+DL, xmin, ymin, mx, my, r);
239			if (my < r->u)
240			paintrect(p->kid+UL, xmin, my, mx, ymax, r);
241			}
242			if (mx < r->r) {
243			if (my > r->d)
244			paintrect(p->kid+DR, mx, ymin, xmax, my, r);
245			if (my < r->u)
246			paintrect(p->kid+UR, mx, my, xmax, ymax, r);
247			}
248			}
249
250
251			PNODE *
252			findrect(x, y, p, r, pd) /* find a rectangle */
253			int x, y;
254			register PNODE *p;
255			register RECT *r;
256			int pd;
257			{
258			int mx, my;
259
260			while (p->kid != NULL && pd--) {
261
262			mx = (r->l + r->r) >> 1;
263			my = (r->d + r->u) >> 1;
264
265			if (x < mx) {
266			r->r = mx;
267			if (y < my) {
268			r->u = my;
269			p = p->kid+DL;
270			} else {
271			r->d = my;
272			p = p->kid+UL;
273			}
274			} else {
275			r->l = mx;
276			if (y < my) {
277			r->u = my;
278			p = p->kid+DR;
279			} else {
280			r->d = my;
281			p = p->kid+UR;
282			}
283			}
284			}
285			return(p);
286			}
287
288
289			scalepict(p, sf) /* scale picture values */
290			register PNODE *p;
291			double sf;
292			{
293			scalecolor(p->v, sf); /* do this node */
294
295			if (p->kid == NULL)
296			return;
297			/* do children */
298			scalepict(p->kid+DL, sf);
299			scalepict(p->kid+DR, sf);
300			scalepict(p->kid+UL, sf);
301			scalepict(p->kid+UR, sf);
302			}
303
304
305			getpictcolrs(yoff, scan, p, xsiz, ysiz) /* get scanline from picture */
306			int yoff;
307			register COLR *scan;
308			register PNODE *p;
309			int xsiz, ysiz;
310			{
311			register int mx;
312			int my;
313
314			if (p->kid == NULL) { /* do this node */
315			setcolr(scan[0], colval(p->v,RED),
316			colval(p->v,GRN),
317			colval(p->v,BLU));
318			for (mx = 1; mx < xsiz; mx++)
319			copycolr(scan[mx], scan[0]);
320			return;
321			}
322			/* do kids */
323			mx = xsiz >> 1;
324			my = ysiz >> 1;
325			if (yoff < my) {
326			getpictcolrs(yoff, scan, p->kid+DL, mx, my);
327			getpictcolrs(yoff, scan+mx, p->kid+DR, xsiz-mx, my);
328			} else {
329			getpictcolrs(yoff-my, scan, p->kid+UL, mx, ysiz-my);
330			getpictcolrs(yoff-my, scan+mx, p->kid+UR, xsiz-mx, ysiz-my);
331			}
332			}
333
334
335			pcopy(p1, p2) /* copy paint node p1 into p2 */
336			register PNODE p1, p2;
337			{
338			copycolor(p2->v, p1->v);
339			p2->x = p1->x;
340			p2->y = p1->y;
341			}
342
343
344			freepkids(p) /* free pnode's children */
345			register PNODE *p;
346			{
347			if (p->kid == NULL)
348			return;
349			freepkids(p->kid+DL);
350			freepkids(p->kid+DR);
351			freepkids(p->kid+UL);
352			freepkids(p->kid+UR);
353			free((char *)p->kid);
354			p->kid = NULL;
355			}
356
357
358			newview(vp) /* change viewing parameters */
359			register VIEW *vp;
360			{
361			char *err;
362
363	greg	1.6	if ((err = setview(vp)) != NULL) {
364	greg	1.1	sprintf(errmsg, "view not set - %s", err);
365			error(COMMAND, errmsg);
366	greg	1.12	} else if (bcmp((char )vp, (char )&ourview, sizeof(VIEW))) {
367			copystruct(&oldview, &ourview);
368			copystruct(&ourview, vp);
369	greg	1.14	newimage();
370	greg	1.1	}
371			}
372
373
374	greg	1.4	moveview(angle, elev, mag, vc) /* move viewpoint */
375			double angle, elev, mag;
376	greg	1.1	FVECT vc;
377			{
378			extern double sqrt(), dist2();
379			double d;
380	greg	1.4	FVECT v1;
381	greg	1.1	VIEW nv;
382			register int i;
383
384			VCOPY(nv.vup, ourview.vup);
385	greg	1.9	nv.hoff = ourview.hoff; nv.voff = ourview.voff;
386	greg	1.1	spinvector(nv.vdir, ourview.vdir, ourview.vup, angle*(PI/180.));
387	greg	1.4	if (elev != 0.0) {
388	greg	1.5	fcross(v1, ourview.vup, nv.vdir);
389	greg	1.4	normalize(v1);
390			spinvector(nv.vdir, nv.vdir, v1, elev*(PI/180.));
391			}
392	greg	1.1	if ((nv.type = ourview.type) == VT_PAR) {
393			nv.horiz = ourview.horiz / mag;
394			nv.vert = ourview.vert / mag;
395	greg	1.3	d = 0.0; /* don't move closer */
396	greg	1.2	for (i = 0; i < 3; i++)
397	greg	1.3	d += (vc[i] - ourview.vp[i])*ourview.vdir[i];
398	greg	1.1	} else {
399			nv.horiz = ourview.horiz;
400			nv.vert = ourview.vert;
401	greg	1.2	d = sqrt(dist2(ourview.vp, vc)) / mag;
402	greg	1.1	}
403	greg	1.2	for (i = 0; i < 3; i++)
404			nv.vp[i] = vc[i] - d*nv.vdir[i];
405	greg	1.1	newview(&nv);
406	greg	1.17	}
407
408
409			zoomview(vp, zf) /* zoom in our out */
410			register VIEW *vp;
411			double zf;
412			{
413			switch (vp->type) {
414			case VT_PAR: /* parallel view */
415			case VT_ANG: /* angular fisheye */
416			vp->horiz /= zf;
417			vp->vert /= zf;
418			return;
419			case VT_PER: /* perspective view */
420			vp->horiz = atan(tan(vp->horiz*(PI/180./2.))/zf) /
421			(PI/180./2.);
422			vp->vert = atan(tan(vp->vert*(PI/180./2.))/zf) /
423			(PI/180./2.);
424			return;
425			case VT_HEM: /* hemispherical fisheye */
426			vp->horiz = sin(vp->horiz*(PI/180./2.))/zf;
427			if (vp->horiz >= 1.0-FTINY)
428			vp->horiz = 180.;
429			else
430			vp->horiz = asin(vp->horiz) / (PI/180./2.);
431			vp->vert = sin(vp->vert*(PI/180./2.))/zf;
432			if (vp->vert >= 1.0-FTINY)
433			vp->vert = 180.;
434			else
435			vp->vert = asin(vp->vert) / (PI/180./2.);
436			return;
437			}
438	greg	1.1	}