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.9 by greg, Fri Aug 18 10:20:10 1995 UTC vs.
Revision 2.33 by greg, Sun Nov 19 01:14:31 2006 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1994 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char       RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		*  image.c - routines for image generation.
6		*
7	<	*     10/17/85
7	>	*  External symbols declared in view.h
8		*/
9
10	<	#include  "standard.h"
10	>	#include "copyright.h"
11
12	+	#include  <ctype.h>
13	+	#include  "rtio.h"
14	+	#include  "rtmath.h"
15	+	#include  "paths.h"
16		#include  "view.h"
17
17	–	#include  "resolu.h"
18
19	<	#include  "paths.h"
19	>	#define  FEQ(x,y)       (fabs((x)-(y)) <= FTINY)
20	>	#define  VEQ(v,w)       (FEQ((v)[0],(w)[0]) && FEQ((v)[1],(w)[1]) \
21	>	&& FEQ((v)[2],(w)[2]))
22
23		VIEW  stdview = STDVIEW;                /* default view parameters */
24
25	+	static gethfunc gethview;
26
27	+
28		char *
29		setview(v)              /* set hvec and vvec, return message on error */
30		register VIEW  *v;
#	Line 28 | Line 32 | register VIEW  *v;
32		static char  ill_horiz[] = "illegal horizontal view size";
33		static char  ill_vert[] = "illegal vertical view size";
34
35	<	if (v->vfore < -FTINY || v->vaft < -FTINY ||
32	<	(v->vaft > FTINY && v->vaft <= v->vfore))
35	>	if (v->vaft < -FTINY || (v->vaft > FTINY && v->vaft <= v->vfore))
36		return("illegal fore/aft clipping plane");
37
38	<	if (normalize(v->vdir) == 0.0)          /* normalize direction */
38	>	if (v->vdist <= FTINY)
39	>	return("illegal view distance");
40	>	v->vdist *= normalize(v->vdir);         /* normalize direction */
41	>	if (v->vdist == 0.0)
42		return("zero view direction");
43
44		if (normalize(v->vup) == 0.0)           /* normalize view up */
#	Line 107 | Line 113 | register VIEW  *v;
113		}
114
115
116	+	void
117		normaspect(va, ap, xp, yp)              /* fix pixel aspect or resolution */
118		double  va;                     /* view aspect ratio */
119		double  *ap;                    /* pixel aspect in (or out if 0) */
#	Line 198 | Line 205 | double  x, y;
205		}
206
207
208	+	void
209		viewloc(ip, v, p)               /* find image location for point */
210		FVECT  ip;
211		register VIEW  *v;
212		FVECT  p;
213		{
214	<	double  d;
214	>	double  d, d2;
215		FVECT  disp;
216
217		disp[0] = p[0] - v->vp[0];
#	Line 216 | Line 224 | FVECT  p;
224		break;
225		case VT_PER:                    /* perspective view */
226		d = DOT(disp,v->vdir);
227	<	ip[2] = sqrt(DOT(disp,disp));
227	>	ip[2] = VLEN(disp);
228		if (d < 0.0) {          /* fold pyramid */
229		ip[2] = -ip[2];
230		d = -d;
#	Line 238 | Line 246 | FVECT  p;
246		ip[2] -= v->vfore;
247		break;
248		case VT_CYL:                    /* cylindrical panorama */
241	–	ip[2] = DOT(disp,v->vdir);
249		d = DOT(disp,v->hvec);
250	<	ip[0] = 180.0/PI * atan2(ip[2],d) / v->horiz + 0.5 - v->hoff;
251	<	ip[1] = DOT(disp,v->vvec)/v->vn2 + 0.5 - v->voff;
252	<	if (v->vfore > FTINY)
253	<	ip[2] = sqrt(DOT(disp,disp)) *
254	<	(1.0 - v->vfore/sqrt(d*d + ip[2]*ip[2]));
255	<	else
249	<	ip[2] = sqrt(DOT(disp,disp));
250	>	d2 = DOT(disp,v->vdir);
251	>	ip[0] = 180.0/PI * atan2(d,d2) / v->horiz + 0.5 - v->hoff;
252	>	d = 1.0/sqrt(d*d + d2*d2);
253	>	ip[1] = DOT(disp,v->vvec)*d/v->vn2 + 0.5 - v->voff;
254	>	ip[2] = VLEN(disp);
255	>	ip[2] *= (1.0 - v->vfore*d);
256		return;
257		case VT_ANG:                    /* angular fisheye */
258		ip[0] = 0.5 - v->hoff;
#	Line 269 | Line 275 | FVECT  p;
275		}
276
277
278	+	void
279		pix2loc(loc, rp, px, py)        /* compute image location from pixel pos. */
280	<	FLOAT  loc[2];
280	>	RREAL  loc[2];
281		register RESOLU  *rp;
282		int  px, py;
283		{
284		register int  x, y;
285
286	<	if (rp->or & YMAJOR) {
286	>	if (rp->rt & YMAJOR) {
287		x = px;
288		y = py;
289		} else {
290		x = py;
291		y = px;
292		}
293	<	if (rp->or & XDECR)
293	>	if (rp->rt & XDECR)
294		x = rp->xr-1 - x;
295	<	if (rp->or & YDECR)
295	>	if (rp->rt & YDECR)
296		y = rp->yr-1 - y;
297		loc[0] = (x+.5)/rp->xr;
298		loc[1] = (y+.5)/rp->yr;
299		}
300
301
302	+	void
303		loc2pix(pp, rp, lx, ly)         /* compute pixel pos. from image location */
304		int  pp[2];
305		register RESOLU  *rp;
#	Line 301 | Line 309 | double  lx, ly;
309
310		x = lx * rp->xr;
311		y = ly * rp->yr;
312	<	if (rp->or & XDECR)
312	>	if (rp->rt & XDECR)
313		x = rp->xr-1 - x;
314	<	if (rp->or & YDECR)
314	>	if (rp->rt & YDECR)
315		y = rp->yr-1 - y;
316	<	if (rp->or & YMAJOR) {
316	>	if (rp->rt & YMAJOR) {
317		pp[0] = x;
318		pp[1] = y;
319		} else {
#	Line 344 | Line 352 | register char  *av[];
352		v->vdir[0] = atof(av[1]);
353		v->vdir[1] = atof(av[2]);
354		v->vdir[2] = atof(av[3]);
355	+	v->vdist = 1.;
356		return(3);
357		case 'u':                       /* up */
358		check(3,"fff");
#	Line 392 | Line 401 | register char  *s;
401		int  na;
402		int  nvopts = 0;
403
404	<	if (*s != '-')
405	<	s = sskip(s);
404	>	while (isspace(*s))
405	>	if (!*s++)
406	>	return(0);
407		while (*s) {
408		ac = 0;
409		do {
410	<	av[ac++] = s;
411	<	while (*s && *s != ' ')
410	>	if (ac || *s == '-')
411	>	av[ac++] = s;
412	>	while (*s && !isspace(*s))
413		s++;
414	<	while (*s == ' ')
414	>	while (isspace(*s))
415		s++;
416		} while (*s && ac < 4);
417		if ((na = getviewopt(vp, ac, av)) >= 0) {
#	Line 414 | Line 425 | register char  *s;
425		}
426
427
428	+	void
429		fprintview(vp, fp)                      /* write out view parameters */
430		register VIEW  *vp;
431		FILE  *fp;
432		{
433		fprintf(fp, " -vt%c", vp->type);
434		fprintf(fp, " -vp %.6g %.6g %.6g", vp->vp[0], vp->vp[1], vp->vp[2]);
435	<	fprintf(fp, " -vd %.6g %.6g %.6g", vp->vdir[0], vp->vdir[1], vp->vdir[2]);
435	>	fprintf(fp, " -vd %.6g %.6g %.6g", vp->vdir[0]*vp->vdist,
436	>	vp->vdir[1]*vp->vdist,
437	>	vp->vdir[2]*vp->vdist);
438		fprintf(fp, " -vu %.6g %.6g %.6g", vp->vup[0], vp->vup[1], vp->vup[2]);
439		fprintf(fp, " -vh %.6g -vv %.6g", vp->horiz, vp->vert);
440		fprintf(fp, " -vo %.6g -va %.6g", vp->vfore, vp->vaft);
#	Line 428 | Line 442 | FILE  *fp;
442		}
443
444
445	+	char *
446	+	viewopt(vp)                             /* translate to minimal view string */
447	+	register VIEW  *vp;
448	+	{
449	+	static char  vwstr[128];
450	+	register char  *cp = vwstr;
451	+
452	+	*cp = '\0';
453	+	if (vp->type != stdview.type) {
454	+	sprintf(cp, " -vt%c", vp->type);
455	+	cp += strlen(cp);
456	+	}
457	+	if (!VEQ(vp->vp,stdview.vp)) {
458	+	sprintf(cp, " -vp %.6g %.6g %.6g",
459	+	vp->vp[0], vp->vp[1], vp->vp[2]);
460	+	cp += strlen(cp);
461	+	}
462	+	if (!FEQ(vp->vdist,stdview.vdist) || !VEQ(vp->vdir,stdview.vdir)) {
463	+	sprintf(cp, " -vd %.6g %.6g %.6g",
464	+	vp->vdir[0]*vp->vdist,
465	+	vp->vdir[1]*vp->vdist,
466	+	vp->vdir[2]*vp->vdist);
467	+	cp += strlen(cp);
468	+	}
469	+	if (!VEQ(vp->vup,stdview.vup)) {
470	+	sprintf(cp, " -vu %.6g %.6g %.6g",
471	+	vp->vup[0], vp->vup[1], vp->vup[2]);
472	+	cp += strlen(cp);
473	+	}
474	+	if (!FEQ(vp->horiz,stdview.horiz)) {
475	+	sprintf(cp, " -vh %.6g", vp->horiz);
476	+	cp += strlen(cp);
477	+	}
478	+	if (!FEQ(vp->vert,stdview.vert)) {
479	+	sprintf(cp, " -vv %.6g", vp->vert);
480	+	cp += strlen(cp);
481	+	}
482	+	if (!FEQ(vp->vfore,stdview.vfore)) {
483	+	sprintf(cp, " -vo %.6g", vp->vfore);
484	+	cp += strlen(cp);
485	+	}
486	+	if (!FEQ(vp->vaft,stdview.vaft)) {
487	+	sprintf(cp, " -va %.6g", vp->vaft);
488	+	cp += strlen(cp);
489	+	}
490	+	if (!FEQ(vp->hoff,stdview.hoff)) {
491	+	sprintf(cp, " -vs %.6g", vp->hoff);
492	+	cp += strlen(cp);
493	+	}
494	+	if (!FEQ(vp->voff,stdview.voff)) {
495	+	sprintf(cp, " -vl %.6g", vp->voff);
496	+	cp += strlen(cp);
497	+	}
498	+	return(vwstr);
499	+	}
500	+
501	+
502		int
503		isview(s)                               /* is this a view string? */
504		char  *s;
505		{
506	<	static char  *altname[]={NULL,VIEWSTR,"rpict","rview","pinterp",NULL};
506	>	static char  *altname[]={NULL,VIEWSTR,"rpict","rview","rvu","rpiece","pinterp",NULL};
507		extern char  *progname;
508		register char  *cp;
509		register char  **an;
#	Line 463 | Line 534 | struct myview {
534		};
535
536
537	<	static
538	<	gethview(s, v)                          /* get view from header */
539	<	char  *s;
540	<	register struct myview  *v;
537	>	static int
538	>	gethview(                               /* get view from header */
539	>	char  *s,
540	>	void  *v
541	>	)
542		{
543	<	if (isview(s) && sscanview(v->hv, s) > 0)
544	<	v->ok++;
543	>	if (isview(s) && sscanview(((struct myview*)v)->hv, s) > 0)
544	>	((struct myview*)v)->ok++;
545	>	return(0);
546		}
547
548
#	Line 482 | Line 555 | RESOLU  *rp;
555		struct myview   mvs;
556		FILE  *fp;
557
558	<	if ((fp = fopen(fname, "r")) == NULL)
558	>	if (fname == NULL || !strcmp(fname, "-"))
559	>	fp = stdin;
560	>	else if ((fp = fopen(fname, "r")) == NULL)
561		return(-1);
562
563		mvs.hv = vp;

Diff Legend

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