src/common/image.c

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

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

/*
 *  image.c - routines for image generation.
 *
 *     10/17/85
 */

#include  "standard.h"

#include  "view.h"

VIEW  stdview = STDVIEW;                /* default view parameters */


char *
setview(v)              /* set hvec and vvec, return message on error */
register VIEW  *v;
{
        extern double  tan(), normalize();

        if (normalize(v->vdir) == 0.0)          /* normalize direction */
                return("zero view direction");

        fcross(v->hvec, v->vdir, v->vup);       /* compute horiz dir */

        if (normalize(v->hvec) == 0.0)
                return("illegal view up vector");

        fcross(v->vvec, v->hvec, v->vdir);      /* compute vert dir */

        if (v->type == VT_PAR)
                v->hn2 = v->horiz;
        else if (v->type == VT_PER)
                v->hn2 = 2.0 * tan(v->horiz*(PI/180.0/2.0));
        else
                return("unknown view type");

        if (v->hn2 <= FTINY || v->hn2 >= FHUGE)
                return("illegal horizontal view size");

        v->hvec[0] *= v->hn2;
        v->hvec[1] *= v->hn2;
        v->hvec[2] *= v->hn2;
        v->hn2 *= v->hn2;

        if (v->type == VT_PAR)
                v->vn2 = v->vert;
        else
                v->vn2 = 2.0 * tan(v->vert*(PI/180.0/2.0));

        if (v->vn2 <= FTINY || v->vn2 >= FHUGE)
                return("illegal vertical view size");

        v->vvec[0] *= v->vn2;
        v->vvec[1] *= v->vn2;
        v->vvec[2] *= v->vn2;
        v->vn2 *= v->vn2;

        return(NULL);
}


normaspect(va, ap, xp, yp)              /* fix pixel aspect or resolution */
double  va;                     /* view aspect ratio */
double  *ap;                    /* pixel aspect in (or out if 0) */
int  *xp, *yp;                  /* x and y resolution in (or out if *ap!=0) */
{
        if (*ap <= FTINY)
                *ap = va * *xp / *yp;           /* compute pixel aspect */
        else if (va * *xp > *ap * *yp)
                *xp = *yp / va * *ap + .5;      /* reduce x resolution */
        else
                *yp = *xp * va / *ap + .5;      /* reduce y resolution */
}


viewray(orig, direc, v, x, y)           /* compute ray origin and direction */
FVECT  orig, direc;
register VIEW  *v;
double  x, y;
{
        x += v->hoff - 0.5;
        y += v->voff - 0.5;

        if (v->type == VT_PAR) {        /* parallel view */
                orig[0] = v->vp[0] + x*v->hvec[0] + y*v->vvec[0];
                orig[1] = v->vp[1] + x*v->hvec[1] + y*v->vvec[1];
                orig[2] = v->vp[2] + x*v->hvec[2] + y*v->vvec[2];
                VCOPY(direc, v->vdir);
        } else {                        /* perspective view */
                VCOPY(orig, v->vp);
                direc[0] = v->vdir[0] + x*v->hvec[0] + y*v->vvec[0];
                direc[1] = v->vdir[1] + x*v->hvec[1] + y*v->vvec[1];
                direc[2] = v->vdir[2] + x*v->hvec[2] + y*v->vvec[2];
                normalize(direc);
        }
}


viewpixel(xp, yp, zp, v, p)             /* find image location for point */
double  *xp, *yp, *zp;
register VIEW  *v;
FVECT  p;
{
        extern double  sqrt();
        double  d;
        FVECT  disp;

        disp[0] = p[0] - v->vp[0];
        disp[1] = p[1] - v->vp[1];
        disp[2] = p[2] - v->vp[2];

        if (v->type == VT_PAR) {        /* parallel view */
                if (zp != NULL)
                        *zp = DOT(disp,v->vdir);
        } else {                        /* perspective view */
                d = DOT(disp,v->vdir);
                if (zp != NULL) {
                        *zp = sqrt(DOT(disp,disp));
                        if (d < 0.0)
                                *zp = -*zp;
                }
                if (d < 0.0)            /* fold pyramid */
                        d = -d;
                if (d > FTINY) {
                        d = 1.0/d;
                        disp[0] *= d;
                        disp[1] *= d;
                        disp[2] *= d;
                }
        }
        *xp = DOT(disp,v->hvec)/v->hn2 + 0.5 - v->hoff;
        *yp = DOT(disp,v->vvec)/v->vn2 + 0.5 - v->voff;
}


int
getviewopt(v, ac, av)                   /* process view argument */
register VIEW  *v;
int  ac;
register char  *av[];
{
#define check(c,n)      if ((av[0][c]&&av[0][c]!=' ') || n>=ac) return(-1)
        extern double  atof();

        if (ac <= 0 || av[0][0] != '-' || av[0][1] != 'v')
                return(-1);
        switch (av[0][2]) {
        case 't':                       /* type */
                if (!av[0][3] || av[0][3]==' ')
                        return(-1);
                check(4,0);
                v->type = av[0][3];
                return(0);
        case 'p':                       /* point */
                check(3,3);
                v->vp[0] = atof(av[1]);
                v->vp[1] = atof(av[2]);
                v->vp[2] = atof(av[3]);
                return(3);
        case 'd':                       /* direction */
                check(3,3);
                v->vdir[0] = atof(av[1]);
                v->vdir[1] = atof(av[2]);
                v->vdir[2] = atof(av[3]);
                return(3);
        case 'u':                       /* up */
                check(3,3);
                v->vup[0] = atof(av[1]);
                v->vup[1] = atof(av[2]);
                v->vup[2] = atof(av[3]);
                return(3);
        case 'h':                       /* horizontal size */
                check(3,1);
                v->horiz = atof(av[1]);
                return(1);
        case 'v':                       /* vertical size */
                check(3,1);
                v->vert = atof(av[1]);
                return(1);
        case 's':                       /* shift */
                check(3,1);
                v->hoff = atof(av[1]);
                return(1);
        case 'l':                       /* lift */
                check(3,1);
                v->voff = atof(av[1]);
                return(1);
        default:
                return(-1);
        }
#undef check
}


int
sscanview(vp, s)                        /* get view parameters from string */
VIEW  *vp;
register char  *s;
{
        int  ac;
        char  *av[4];
        int  na;
        int  nvopts = 0;

        while (*s == ' ')
                s++;
        while (*s) {
                ac = 0;
                do {
                        av[ac++] = s;
                        while (*s && *s != ' ')
                                s++;
                        while (*s == ' ')
                                s++;
                } while (*s && ac < 4);
                if ((na = getviewopt(vp, ac, av)) >= 0) {
                        if (na+1 < ac)
                                s = av[na+1];
                        nvopts++;
                } else if (ac > 1)
                        s = av[1];
        }
        return(nvopts);
}


fprintview(vp, fp)                      /* write out view parameters */
register VIEW  *vp;
FILE  *fp;
{
        fprintf(fp, " -vt%c", vp->type);
        fprintf(fp, " -vp %.6g %.6g %.6g", vp->vp[0], vp->vp[1], vp->vp[2]);
        fprintf(fp, " -vd %.6g %.6g %.6g", vp->vdir[0], vp->vdir[1], vp->vdir[2]);
        fprintf(fp, " -vu %.6g %.6g %.6g", vp->vup[0], vp->vup[1], vp->vup[2]);
        fprintf(fp, " -vh %.6g -vv %.6g", vp->horiz, vp->vert);
        fprintf(fp, " -vs %.6g -vl %.6g", vp->hoff, vp->voff);
}


static VIEW  *hview;                    /* view from header */
static int  gothview;                   /* success indicator */
static char  *altname[] = {NULL,"rpict","rview","pinterp",VIEWSTR,NULL};


static
gethview(s)                             /* get view from header */
char  *s;
{
        register char  **an;

        for (an = altname; *an != NULL; an++)
                if (!strncmp(*an, s, strlen(*an))) {
                        if (sscanview(hview, s+strlen(*an)) > 0)
                                gothview++;
                        return;
                }
}


int
viewfile(fname, vp, xp, yp)             /* get view from file */
char  *fname;
VIEW  *vp;
int  *xp, *yp;
{
        extern char  *progname;
        FILE  *fp;

        if ((fp = fopen(fname, "r")) == NULL)
                return(-1);

        altname[0] = progname;
        hview = vp;
        gothview = 0;

        getheader(fp, gethview);

        if (xp != NULL && yp != NULL
                        && fgetresolu(xp, yp, fp) == -1)
                gothview = 0;

        fclose(fp);

        return(gothview);
}
Revision:	1.11
Committed:	Fri Sep 21 17:06:31 1990 UTC (33 years, 7 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.10:	+9 -4 lines
Log Message:	added folding of pyramid to viewpixel()
#	User	Rev	Content
1	greg	1.1	/* Copyright (c) 1986 Regents of the University of California */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* image.c - routines for image generation.
9			*
10			* 10/17/85
11			*/
12
13			#include "standard.h"
14
15			#include "view.h"
16
17	greg	1.5	VIEW stdview = STDVIEW; /* default view parameters */
18	greg	1.1
19
20			char *
21	greg	1.5	setview(v) /* set hvec and vvec, return message on error */
22			register VIEW *v;
23	greg	1.3	{
24	greg	1.5	extern double tan(), normalize();
25	greg	1.3
26	greg	1.1	if (normalize(v->vdir) == 0.0) /* normalize direction */
27			return("zero view direction");
28
29	greg	1.5	fcross(v->hvec, v->vdir, v->vup); /* compute horiz dir */
30
31			if (normalize(v->hvec) == 0.0)
32	greg	1.1	return("illegal view up vector");
33
34	greg	1.5	fcross(v->vvec, v->hvec, v->vdir); /* compute vert dir */
35
36	greg	1.1	if (v->type == VT_PAR)
37	greg	1.5	v->hn2 = v->horiz;
38	greg	1.1	else if (v->type == VT_PER)
39	greg	1.5	v->hn2 = 2.0 * tan(v->horiz*(PI/180.0/2.0));
40	greg	1.1	else
41			return("unknown view type");
42
43	greg	1.5	if (v->hn2 <= FTINY \|\| v->hn2 >= FHUGE)
44	greg	1.1	return("illegal horizontal view size");
45
46	greg	1.5	v->hvec[0] *= v->hn2;
47			v->hvec[1] *= v->hn2;
48			v->hvec[2] *= v->hn2;
49			v->hn2 *= v->hn2;
50	greg	1.1
51			if (v->type == VT_PAR)
52	greg	1.5	v->vn2 = v->vert;
53	greg	1.1	else
54	greg	1.5	v->vn2 = 2.0 * tan(v->vert*(PI/180.0/2.0));
55	greg	1.1
56	greg	1.5	if (v->vn2 <= FTINY \|\| v->vn2 >= FHUGE)
57	greg	1.1	return("illegal vertical view size");
58
59	greg	1.5	v->vvec[0] *= v->vn2;
60			v->vvec[1] *= v->vn2;
61			v->vvec[2] *= v->vn2;
62			v->vn2 *= v->vn2;
63	greg	1.1
64			return(NULL);
65			}
66
67
68	greg	1.7	normaspect(va, ap, xp, yp) /* fix pixel aspect or resolution */
69			double va; /* view aspect ratio */
70			double ap; / pixel aspect in (or out if 0) */
71			int xp, yp; /* x and y resolution in (or out if ap!=0) /
72	greg	1.6	{
73			if (*ap <= FTINY)
74	greg	1.7	ap = va xp / yp; /* compute pixel aspect */
75	greg	1.6	else if (va * xp > ap * *yp)
76	greg	1.10	xp = yp / va * ap + .5; / reduce x resolution */
77	greg	1.6	else
78	greg	1.10	yp = xp * va / ap + .5; / reduce y resolution */
79	greg	1.6	}
80
81
82	greg	1.5	viewray(orig, direc, v, x, y) /* compute ray origin and direction */
83	greg	1.1	FVECT orig, direc;
84			register VIEW *v;
85			double x, y;
86			{
87	greg	1.5	x += v->hoff - 0.5;
88			y += v->voff - 0.5;
89	greg	1.1
90			if (v->type == VT_PAR) { /* parallel view */
91	greg	1.5	orig[0] = v->vp[0] + xv->hvec[0] + yv->vvec[0];
92			orig[1] = v->vp[1] + xv->hvec[1] + yv->vvec[1];
93			orig[2] = v->vp[2] + xv->hvec[2] + yv->vvec[2];
94	greg	1.1	VCOPY(direc, v->vdir);
95			} else { /* perspective view */
96			VCOPY(orig, v->vp);
97	greg	1.5	direc[0] = v->vdir[0] + xv->hvec[0] + yv->vvec[0];
98			direc[1] = v->vdir[1] + xv->hvec[1] + yv->vvec[1];
99			direc[2] = v->vdir[2] + xv->hvec[2] + yv->vvec[2];
100	greg	1.1	normalize(direc);
101			}
102			}
103
104
105	greg	1.5	viewpixel(xp, yp, zp, v, p) /* find image location for point */
106	greg	1.3	double xp, yp, *zp;
107			register VIEW *v;
108			FVECT p;
109			{
110			extern double sqrt();
111			double d;
112			FVECT disp;
113	greg	1.5
114	greg	1.3	disp[0] = p[0] - v->vp[0];
115			disp[1] = p[1] - v->vp[1];
116			disp[2] = p[2] - v->vp[2];
117
118			if (v->type == VT_PAR) { /* parallel view */
119			if (zp != NULL)
120			*zp = DOT(disp,v->vdir);
121			} else { /* perspective view */
122	greg	1.11	d = DOT(disp,v->vdir);
123	greg	1.3	if (zp != NULL) {
124			*zp = sqrt(DOT(disp,disp));
125			if (d < 0.0)
126			zp = -zp;
127			}
128	greg	1.11	if (d < 0.0) /* fold pyramid */
129			d = -d;
130			if (d > FTINY) {
131			d = 1.0/d;
132			disp[0] *= d;
133			disp[1] *= d;
134			disp[2] *= d;
135			}
136	greg	1.3	}
137	greg	1.5	*xp = DOT(disp,v->hvec)/v->hn2 + 0.5 - v->hoff;
138			*yp = DOT(disp,v->vvec)/v->vn2 + 0.5 - v->voff;
139	greg	1.3	}
140
141
142	greg	1.5	int
143			getviewopt(v, ac, av) /* process view argument */
144			register VIEW *v;
145			int ac;
146			register char *av[];
147			{
148			#define check(c,n) if ((av[0][c]&&av[0][c]!=' ') \|\| n>=ac) return(-1)
149			extern double atof();
150
151	greg	1.9	if (ac <= 0 \|\| av[0][0] != '-' \|\| av[0][1] != 'v')
152	greg	1.5	return(-1);
153			switch (av[0][2]) {
154			case 't': /* type */
155			if (!av[0][3] \|\| av[0][3]==' ')
156			return(-1);
157			check(4,0);
158			v->type = av[0][3];
159			return(0);
160			case 'p': /* point */
161			check(3,3);
162			v->vp[0] = atof(av[1]);
163			v->vp[1] = atof(av[2]);
164			v->vp[2] = atof(av[3]);
165			return(3);
166			case 'd': /* direction */
167			check(3,3);
168			v->vdir[0] = atof(av[1]);
169			v->vdir[1] = atof(av[2]);
170			v->vdir[2] = atof(av[3]);
171			return(3);
172			case 'u': /* up */
173			check(3,3);
174			v->vup[0] = atof(av[1]);
175			v->vup[1] = atof(av[2]);
176			v->vup[2] = atof(av[3]);
177			return(3);
178			case 'h': /* horizontal size */
179			check(3,1);
180			v->horiz = atof(av[1]);
181			return(1);
182			case 'v': /* vertical size */
183			check(3,1);
184			v->vert = atof(av[1]);
185			return(1);
186			case 's': /* shift */
187			check(3,1);
188			v->hoff = atof(av[1]);
189			return(1);
190			case 'l': /* lift */
191			check(3,1);
192			v->voff = atof(av[1]);
193			return(1);
194			default:
195			return(-1);
196			}
197			#undef check
198			}
199
200
201			int
202			sscanview(vp, s) /* get view parameters from string */
203			VIEW *vp;
204	greg	1.1	register char *s;
205			{
206	greg	1.5	int ac;
207			char *av[4];
208			int na;
209			int nvopts = 0;
210
211			while (*s == ' ')
212			s++;
213	greg	1.9	while (*s) {
214	greg	1.5	ac = 0;
215			do {
216			av[ac++] = s;
217			while (s && s != ' ')
218			s++;
219			while (*s == ' ')
220			s++;
221			} while (*s && ac < 4);
222			if ((na = getviewopt(vp, ac, av)) >= 0) {
223			if (na+1 < ac)
224			s = av[na+1];
225			nvopts++;
226	greg	1.9	} else if (ac > 1)
227			s = av[1];
228			}
229	greg	1.5	return(nvopts);
230	greg	1.1	}
231
232
233			fprintview(vp, fp) /* write out view parameters */
234			register VIEW *vp;
235			FILE *fp;
236			{
237			fprintf(fp, " -vt%c", vp->type);
238			fprintf(fp, " -vp %.6g %.6g %.6g", vp->vp[0], vp->vp[1], vp->vp[2]);
239			fprintf(fp, " -vd %.6g %.6g %.6g", vp->vdir[0], vp->vdir[1], vp->vdir[2]);
240			fprintf(fp, " -vu %.6g %.6g %.6g", vp->vup[0], vp->vup[1], vp->vup[2]);
241			fprintf(fp, " -vh %.6g -vv %.6g", vp->horiz, vp->vert);
242	greg	1.9	fprintf(fp, " -vs %.6g -vl %.6g", vp->hoff, vp->voff);
243	greg	1.1	}
244
245
246			static VIEW hview; / view from header */
247			static int gothview; /* success indicator */
248	greg	1.3	static char *altname[] = {NULL,"rpict","rview","pinterp",VIEWSTR,NULL};
249	greg	1.1
250
251			static
252			gethview(s) /* get view from header */
253			char *s;
254			{
255			register char **an;
256
257			for (an = altname; *an != NULL; an++)
258			if (!strncmp(an, s, strlen(an))) {
259	greg	1.5	if (sscanview(hview, s+strlen(*an)) > 0)
260	greg	1.1	gothview++;
261			return;
262			}
263			}
264
265
266			int
267	greg	1.8	viewfile(fname, vp, xp, yp) /* get view from file */
268	greg	1.1	char *fname;
269			VIEW *vp;
270	greg	1.8	int xp, yp;
271	greg	1.1	{
272			extern char *progname;
273			FILE *fp;
274
275			if ((fp = fopen(fname, "r")) == NULL)
276			return(-1);
277
278			altname[0] = progname;
279			hview = vp;
280			gothview = 0;
281
282			getheader(fp, gethview);
283	greg	1.8
284			if (xp != NULL && yp != NULL
285			&& fgetresolu(xp, yp, fp) == -1)
286			gothview = 0;
287	greg	1.1
288			fclose(fp);
289
290			return(gothview);
291			}