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.16 by greg, Sat Feb 22 02:07:22 2003 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	+	/* ====================================================================
11	+	* The Radiance Software License, Version 1.0
12	+	*
13	+	* Copyright (c) 1990 - 2002 The Regents of the University of California,
14	+	* through Lawrence Berkeley National Laboratory.   All rights reserved.
15	+	*
16	+	* Redistribution and use in source and binary forms, with or without
17	+	* modification, are permitted provided that the following conditions
18	+	* are met:
19	+	*
20	+	* 1. Redistributions of source code must retain the above copyright
21	+	*         notice, this list of conditions and the following disclaimer.
22	+	*
23	+	* 2. Redistributions in binary form must reproduce the above copyright
24	+	*       notice, this list of conditions and the following disclaimer in
25	+	*       the documentation and/or other materials provided with the
26	+	*       distribution.
27	+	*
28	+	* 3. The end-user documentation included with the redistribution,
29	+	*           if any, must include the following acknowledgment:
30	+	*             "This product includes Radiance software
31	+	*                 (http://radsite.lbl.gov/)
32	+	*                 developed by the Lawrence Berkeley National Laboratory
33	+	*               (http://www.lbl.gov/)."
34	+	*       Alternately, this acknowledgment may appear in the software itself,
35	+	*       if and wherever such third-party acknowledgments normally appear.
36	+	*
37	+	* 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
38	+	*       and "The Regents of the University of California" must
39	+	*       not be used to endorse or promote products derived from this
40	+	*       software without prior written permission. For written
41	+	*       permission, please contact [email protected].
42	+	*
43	+	* 5. Products derived from this software may not be called "Radiance",
44	+	*       nor may "Radiance" appear in their name, without prior written
45	+	*       permission of Lawrence Berkeley National Laboratory.
46	+	*
47	+	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
48	+	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
49	+	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
50	+	* DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
51	+	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
52	+	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
53	+	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
54	+	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
55	+	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
56	+	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
57	+	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58	+	* SUCH DAMAGE.
59	+	* ====================================================================
60	+	*
61	+	* This software consists of voluntary contributions made by many
62	+	* individuals on behalf of Lawrence Berkeley National Laboratory.   For more
63	+	* information on Lawrence Berkeley National Laboratory, please see
64	+	* <http://www.lbl.gov/>.
65	+	*/
66	+
67		#include  "standard.h"
68
69		#include  "view.h"
70
17	–	#include  "resolu.h"
18	–
71		#include  "paths.h"
72
73	+	#define  FEQ(x,y)       (fabs((x)-(y)) <= FTINY)
74	+	#define  VEQ(v,w)       (FEQ((v)[0],(w)[0]) && FEQ((v)[1],(w)[1]) \
75	+	&& FEQ((v)[2],(w)[2]))
76	+
77		VIEW  stdview = STDVIEW;                /* default view parameters */
78
79
#	Line 28 | Line 84 | register VIEW  *v;
84		static char  ill_horiz[] = "illegal horizontal view size";
85		static char  ill_vert[] = "illegal vertical view size";
86
87	<	if (v->vfore < -FTINY || v->vaft < -FTINY ||
32	<	(v->vaft > FTINY && v->vaft <= v->vfore))
87	>	if (v->vaft < -FTINY || (v->vaft > FTINY && v->vaft <= v->vfore))
88		return("illegal fore/aft clipping plane");
89
90		if (normalize(v->vdir) == 0.0)          /* normalize direction */
#	Line 107 | Line 162 | register VIEW  *v;
162		}
163
164
165	+	void
166		normaspect(va, ap, xp, yp)              /* fix pixel aspect or resolution */
167		double  va;                     /* view aspect ratio */
168		double  *ap;                    /* pixel aspect in (or out if 0) */
#	Line 198 | Line 254 | double  x, y;
254		}
255
256
257	+	void
258		viewloc(ip, v, p)               /* find image location for point */
259		FVECT  ip;
260		register VIEW  *v;
261		FVECT  p;
262		{
263	<	double  d;
263	>	double  d, d2;
264		FVECT  disp;
265
266		disp[0] = p[0] - v->vp[0];
#	Line 216 | Line 273 | FVECT  p;
273		break;
274		case VT_PER:                    /* perspective view */
275		d = DOT(disp,v->vdir);
276	<	ip[2] = sqrt(DOT(disp,disp));
276	>	ip[2] = VLEN(disp);
277		if (d < 0.0) {          /* fold pyramid */
278		ip[2] = -ip[2];
279		d = -d;
#	Line 238 | Line 295 | FVECT  p;
295		ip[2] -= v->vfore;
296		break;
297		case VT_CYL:                    /* cylindrical panorama */
241	–	ip[2] = DOT(disp,v->vdir);
298		d = DOT(disp,v->hvec);
299	<	ip[0] = 180.0/PI * atan2(ip[2],d) / v->horiz + 0.5 - v->hoff;
300	<	ip[1] = DOT(disp,v->vvec)/v->vn2 + 0.5 - v->voff;
301	<	if (v->vfore > FTINY)
302	<	ip[2] = sqrt(DOT(disp,disp)) *
303	<	(1.0 - v->vfore/sqrt(d*d + ip[2]*ip[2]));
304	<	else
249	<	ip[2] = sqrt(DOT(disp,disp));
299	>	d2 = DOT(disp,v->vdir);
300	>	ip[0] = 180.0/PI * atan2(d,d2) / v->horiz + 0.5 - v->hoff;
301	>	d = 1.0/sqrt(d*d + d2*d2);
302	>	ip[1] = DOT(disp,v->vvec)*d/v->vn2 + 0.5 - v->voff;
303	>	ip[2] = VLEN(disp);
304	>	ip[2] *= (1.0 - v->vfore*d);
305		return;
306		case VT_ANG:                    /* angular fisheye */
307		ip[0] = 0.5 - v->hoff;
#	Line 269 | Line 324 | FVECT  p;
324		}
325
326
327	+	void
328		pix2loc(loc, rp, px, py)        /* compute image location from pixel pos. */
329		FLOAT  loc[2];
330		register RESOLU  *rp;
#	Line 276 | Line 332 | int  px, py;
332		{
333		register int  x, y;
334
335	<	if (rp->or & YMAJOR) {
335	>	if (rp->rt & YMAJOR) {
336		x = px;
337		y = py;
338		} else {
339		x = py;
340		y = px;
341		}
342	<	if (rp->or & XDECR)
342	>	if (rp->rt & XDECR)
343		x = rp->xr-1 - x;
344	<	if (rp->or & YDECR)
344	>	if (rp->rt & YDECR)
345		y = rp->yr-1 - y;
346		loc[0] = (x+.5)/rp->xr;
347		loc[1] = (y+.5)/rp->yr;
348		}
349
350
351	+	void
352		loc2pix(pp, rp, lx, ly)         /* compute pixel pos. from image location */
353		int  pp[2];
354		register RESOLU  *rp;
#	Line 301 | Line 358 | double  lx, ly;
358
359		x = lx * rp->xr;
360		y = ly * rp->yr;
361	<	if (rp->or & XDECR)
361	>	if (rp->rt & XDECR)
362		x = rp->xr-1 - x;
363	<	if (rp->or & YDECR)
363	>	if (rp->rt & YDECR)
364		y = rp->yr-1 - y;
365	<	if (rp->or & YMAJOR) {
365	>	if (rp->rt & YMAJOR) {
366		pp[0] = x;
367		pp[1] = y;
368		} else {
#	Line 393 | Line 450 | register char  *s;
450		int  nvopts = 0;
451
452		if (*s != '-')
453	<	s = sskip(s);
453	>	s = sskip2(s,1);
454		while (*s) {
455		ac = 0;
456		do {
#	Line 414 | Line 471 | register char  *s;
471		}
472
473
474	+	void
475		fprintview(vp, fp)                      /* write out view parameters */
476		register VIEW  *vp;
477		FILE  *fp;
#	Line 428 | Line 486 | FILE  *fp;
486		}
487
488
489	+	char *
490	+	viewopt(vp)                             /* translate to minimal view string */
491	+	register VIEW  *vp;
492	+	{
493	+	static char  vwstr[128];
494	+	register char  *cp = vwstr;
495	+
496	+	if (vp->type != stdview.type) {
497	+	sprintf(cp, " -vt%c", vp->type);
498	+	cp += strlen(cp);
499	+	}
500	+	if (!VEQ(vp->vp,stdview.vp)) {
501	+	sprintf(cp, " -vp %.6g %.6g %.6g",
502	+	vp->vp[0], vp->vp[1], vp->vp[2]);
503	+	cp += strlen(cp);
504	+	}
505	+	if (!VEQ(vp->vdir,stdview.vdir)) {
506	+	sprintf(cp, " -vd %.6g %.6g %.6g",
507	+	vp->vdir[0], vp->vdir[1], vp->vdir[2]);
508	+	cp += strlen(cp);
509	+	}
510	+	if (!VEQ(vp->vup,stdview.vup)) {
511	+	sprintf(cp, " -vu %.6g %.6g %.6g",
512	+	vp->vup[0], vp->vup[1], vp->vup[2]);
513	+	cp += strlen(cp);
514	+	}
515	+	if (!FEQ(vp->horiz,stdview.horiz)) {
516	+	sprintf(cp, " -vh %.6g", vp->horiz);
517	+	cp += strlen(cp);
518	+	}
519	+	if (!FEQ(vp->vert,stdview.vert)) {
520	+	sprintf(cp, " -vv %.6g", vp->vert);
521	+	cp += strlen(cp);
522	+	}
523	+	if (!FEQ(vp->vfore,stdview.vfore)) {
524	+	sprintf(cp, " -vo %.6g", vp->vfore);
525	+	cp += strlen(cp);
526	+	}
527	+	if (!FEQ(vp->vaft,stdview.vaft)) {
528	+	sprintf(cp, " -va %.6g", vp->vaft);
529	+	cp += strlen(cp);
530	+	}
531	+	if (!FEQ(vp->hoff,stdview.hoff)) {
532	+	sprintf(cp, " -vs %.6g", vp->hoff);
533	+	cp += strlen(cp);
534	+	}
535	+	if (!FEQ(vp->voff,stdview.voff)) {
536	+	sprintf(cp, " -vl %.6g", vp->voff);
537	+	cp += strlen(cp);
538	+	}
539	+	return(vwstr);
540	+	}
541	+
542	+
543		int
544		isview(s)                               /* is this a view string? */
545		char  *s;
#	Line 463 | Line 575 | struct myview {
575		};
576
577
578	<	static
578	>	static int
579		gethview(s, v)                          /* get view from header */
580		char  *s;
581		register struct myview  *v;
582		{
583		if (isview(s) && sscanview(v->hv, s) > 0)
584		v->ok++;
585	+	return(0);
586		}
587
588
#	Line 482 | Line 595 | RESOLU  *rp;
595		struct myview   mvs;
596		FILE  *fp;
597
598	<	if ((fp = fopen(fname, "r")) == NULL)
598	>	if (fname == NULL || !strcmp(fname, "-"))
599	>	fp = stdin;
600	>	else if ((fp = fopen(fname, "r")) == NULL)
601		return(-1);
602
603		mvs.hv = vp;
604		mvs.ok = 0;
605
606	<	getheader(fp, gethview, &mvs);
606	>	getheader(fp, (int (*)(char *, char *))&gethview, (char *)&mvs);
607
608		if (rp != NULL && !fgetsresolu(rp, fp))
609		mvs.ok = 0;

Diff Legend

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