src/util/vwrays.c

#ifndef lint
static const char       RCSid[] = "$Id: vwrays.c,v 3.9 2003/10/22 02:06:35 greg Exp $";
#endif
/*
 * Compute rays corresponding to a given picture or view.
 */

#include "platform.h"
#include "standard.h"
#include "view.h"

typedef void putfunc(FVECT ro, FVECT rd);
static putfunc puta;
static putfunc putf;
static putfunc putd;
static void pix2rays(FILE *fp);
static void putrays(void);

static putfunc *putr = puta;

VIEW    vw = STDVIEW;

RESOLU  rs = {PIXSTANDARD, 512, 512};

double  pa = 1.;

int     zfd = -1;

int     fromstdin = 0;

char    *progname;


int
main(
        int     argc,
        char    *argv[]
)
{
        char    *err;
        int     rval, getdim = 0;
        register int    i;

        progname = argv[0];
        if (argc < 2)
                goto userr;
        for (i = 1; i < argc && argv[i][0] == '-'; i++)
                switch (argv[i][1]) {
                case 'f':                       /* output format */
                        switch (argv[i][2]) {
                        case 'a':                       /* ASCII */
                                putr = puta;
                                break;
                        case 'f':                       /* float */
                                putr = putf;
                                break;
                        case 'd':                       /* double */
                                putr = putd;
                                break;
                        default:
                                goto userr;
                        }
                        break;
                case 'v':                       /* view file or option */
                        if (argv[i][2] == 'f') {
                                rval = viewfile(argv[++i], &vw, NULL);
                                if (rval <= 0) {
                                        fprintf(stderr,
                                                "%s: no view in file\n",
                                                        argv[i]);
                                        exit(1);
                                }
                                break;
                        }
                        rval = getviewopt(&vw, argc-i, argv+i);
                        if (rval < 0)
                                goto userr;
                        i += rval;
                        break;
                case 'd':                       /* report dimensions only */
                        getdim++;
                        break;
                case 'x':                       /* x resolution */
                        rs.xr = atoi(argv[++i]);
                        if (rs.xr <= 0) {
                                fprintf(stderr, "%s: bad x resolution\n",
                                                progname);
                                exit(1);
                        }
                        break;
                case 'y':                       /* y resolution */
                        rs.yr = atoi(argv[++i]);
                        if (rs.yr <= 0) {
                                fprintf(stderr, "%s: bad y resolution\n",
                                                progname);
                                exit(1);
                        }
                        break;
                case 'p':                       /* pixel aspect ratio */
                        pa = atof(argv[++i]);
                        break;
                case 'i':                       /* get pixels from stdin */
                        fromstdin = 1;
                        break;
                default:
                        goto userr;
                }
        if ((i > argc) | (i+2 < argc))
                goto userr;
        if (i < argc) {
                rval = viewfile(argv[i], &vw, &rs);
                if (rval <= 0) {
                        fprintf(stderr, "%s: no view in picture\n", argv[i]);
                        exit(1);
                }
                if (i+1 < argc) {
                        zfd = open(argv[i+1], O_RDONLY);
                        if (zfd < 0) {
                                fprintf(stderr,
                                        "%s: cannot open depth buffer\n",
                                                argv[i+1]);
                                exit(1);
                        }
                }
        }
        if ((err = setview(&vw)) != NULL) {
                fprintf(stderr, "%s: %s\n", progname, err);
                exit(1);
        }
        if (i == argc)
                normaspect(viewaspect(&vw), &pa, &rs.xr, &rs.yr);
        if (getdim) {
                printf("-x %d -y %d -ld%c\n", rs.xr, rs.yr,
                                vw.vaft > FTINY ? '+' : '-');
                exit(0);
        }
        if (fromstdin)
                pix2rays(stdin);
        else
                putrays();
        exit(0);
userr:
        fprintf(stderr,
        "Usage: %s [ -i -f{a|f|d} | -d ] { view opts .. | picture [zbuf] }\n",
                        progname);
        exit(1);
}


static void
pix2rays(
        FILE *fp
)
{
        static FVECT    rorg, rdir;
        float   zval;
        double  px, py;
        int     pp[2];
        double  d;
        register int    i;

        while (fscanf(fp, "%lf %lf", &px, &py) == 2) {
                if (px < 0 || px >= rs.xr ||
                                py < 0 || py >= rs.yr) {
                        fprintf(stderr,
                                "%s: (x,y) pair (%.0f,%.0f) out of range\n",
                                        progname, px, py);
                        exit(1);
                }
                if (zfd >= 0) {
                        loc2pix(pp, &rs, px/rs.xr, py/rs.yr);
                        if (lseek(zfd,
                                (pp[1]*scanlen(&rs)+pp[0])*sizeof(float),
                                                SEEK_SET) < 0 ||
                                        read(zfd, &zval, sizeof(float))
                                                < sizeof(float)) {
                                fprintf(stderr, "%s: depth buffer read error\n",
                                                progname);
                                exit(1);
                        }
                }
                d = viewray(rorg, rdir, &vw, px/rs.xr, py/rs.yr);
                if (d < -FTINY)
                        rorg[0] = rorg[1] = rorg[2] =
                        rdir[0] = rdir[1] = rdir[2] = 0.;
                else if (zfd >= 0)
                        for (i = 0; i < 3; i++) {
                                rorg[i] += rdir[i]*zval;
                                rdir[i] = -rdir[i];
                        }
                else if (d > FTINY) {
                        rdir[0] *= d; rdir[1] *= d; rdir[2] *= d;
                }
                (*putr)(rorg, rdir);
        }
        if (!feof(fp)) {
                fprintf(stderr, "%s: expected px py on input\n", progname);
                exit(1);
        }
}


static void
putrays(void)
{
        static RREAL    loc[2];
        static FVECT    rorg, rdir;
        float   *zbuf = NULL;
        int     sc;
        double  d;
        register int    si, i;

        if (zfd >= 0) {
                zbuf = (float *)malloc(scanlen(&rs)*sizeof(float));
                if (zbuf == NULL) {
                        fprintf(stderr, "%s: not enough memory\n", progname);
                        exit(1);
                }
        }
        for (sc = 0; sc < numscans(&rs); sc++) {
                if (zfd >= 0) {
                        if (read(zfd, zbuf, scanlen(&rs)*sizeof(float)) <
                                        scanlen(&rs)*sizeof(float)) {
                                fprintf(stderr, "%s: depth buffer read error\n",
                                                progname);
                                exit(1);
                        }
                }
                for (si = 0; si < scanlen(&rs); si++) {
                        pix2loc(loc, &rs, si, sc);
                        d = viewray(rorg, rdir, &vw, loc[0], loc[1]);
                        if (d < -FTINY)
                                rorg[0] = rorg[1] = rorg[2] =
                                rdir[0] = rdir[1] = rdir[2] = 0.;
                        else if (zfd >= 0)
                                for (i = 0; i < 3; i++) {
                                        rorg[i] += rdir[i]*zbuf[si];
                                        rdir[i] = -rdir[i];
                                }
                        else if (d > FTINY) {
                                rdir[0] *= d; rdir[1] *= d; rdir[2] *= d;
                        }
                        (*putr)(rorg, rdir);
                }
        }
        if (zfd >= 0)
                free((void *)zbuf);
}


static void
puta(           /* put out ray in ASCII format */
        FVECT   ro,
        FVECT   rd
)
{
        printf("%.5e %.5e %.5e %.5e %.5e %.5e\n",
                        ro[0], ro[1], ro[2],
                        rd[0], rd[1], rd[2]);
}


static void
putf(           /* put out ray in float format */
        FVECT   ro,
        FVECT   rd
)
{
        float v[6];

        v[0] = ro[0]; v[1] = ro[1]; v[2] = ro[2];
        v[3] = rd[0]; v[4] = rd[1]; v[5] = rd[2];
        fwrite(v, sizeof(float), 6, stdout);
}


static void
putd(           /* put out ray in double format */
        FVECT   ro,
        FVECT   rd
)
{
        double v[6];

        v[0] = ro[0]; v[1] = ro[1]; v[2] = ro[2];
        v[3] = rd[0]; v[4] = rd[1]; v[5] = rd[2];
        fwrite(v, sizeof(double), 6, stdout);
}
Revision:	3.10
Committed:	Fri Mar 26 23:34:23 2004 UTC (20 years, 1 month ago) by schorsch
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R6, rad3R6P1
Changes since 3.9:	+35 -15 lines
Log Message:	Continued ANSIfication.
#	User	Rev	Content
1	gregl	3.1	#ifndef lint
2	schorsch	3.10	static const char RCSid[] = "$Id: vwrays.c,v 3.9 2003/10/22 02:06:35 greg Exp $";
3	gregl	3.1	#endif
4			/*
5			* Compute rays corresponding to a given picture or view.
6			*/
7
8	greg	3.9	#include "platform.h"
9	gregl	3.1	#include "standard.h"
10			#include "view.h"
11
12	schorsch	3.10	typedef void putfunc(FVECT ro, FVECT rd);
13			static putfunc puta;
14			static putfunc putf;
15			static putfunc putd;
16			static void pix2rays(FILE *fp);
17			static void putrays(void);
18	gregl	3.1
19	schorsch	3.10	static putfunc *putr = puta;
20	gregl	3.1
21			VIEW vw = STDVIEW;
22
23			RESOLU rs = {PIXSTANDARD, 512, 512};
24
25			double pa = 1.;
26
27			int zfd = -1;
28
29	greg	3.4	int fromstdin = 0;
30
31	gregl	3.1	char *progname;
32
33
34	schorsch	3.10	int
35			main(
36			int argc,
37			char *argv[]
38			)
39	gregl	3.1	{
40			char *err;
41			int rval, getdim = 0;
42			register int i;
43
44			progname = argv[0];
45			if (argc < 2)
46			goto userr;
47			for (i = 1; i < argc && argv[i][0] == '-'; i++)
48			switch (argv[i][1]) {
49			case 'f': /* output format */
50			switch (argv[i][2]) {
51			case 'a': /* ASCII */
52			putr = puta;
53			break;
54			case 'f': /* float */
55			putr = putf;
56			break;
57			case 'd': /* double */
58			putr = putd;
59			break;
60			default:
61			goto userr;
62			}
63			break;
64			case 'v': /* view file or option */
65			if (argv[i][2] == 'f') {
66			rval = viewfile(argv[++i], &vw, NULL);
67			if (rval <= 0) {
68			fprintf(stderr,
69			"%s: no view in file\n",
70			argv[i]);
71			exit(1);
72			}
73			break;
74			}
75			rval = getviewopt(&vw, argc-i, argv+i);
76			if (rval < 0)
77			goto userr;
78			i += rval;
79			break;
80			case 'd': /* report dimensions only */
81			getdim++;
82			break;
83			case 'x': /* x resolution */
84			rs.xr = atoi(argv[++i]);
85			if (rs.xr <= 0) {
86			fprintf(stderr, "%s: bad x resolution\n",
87			progname);
88			exit(1);
89			}
90			break;
91			case 'y': /* y resolution */
92			rs.yr = atoi(argv[++i]);
93			if (rs.yr <= 0) {
94			fprintf(stderr, "%s: bad y resolution\n",
95			progname);
96			exit(1);
97			}
98			break;
99			case 'p': /* pixel aspect ratio */
100			pa = atof(argv[++i]);
101			break;
102	greg	3.4	case 'i': /* get pixels from stdin */
103			fromstdin = 1;
104			break;
105	gregl	3.1	default:
106			goto userr;
107			}
108	schorsch	3.7	if ((i > argc) \| (i+2 < argc))
109	gregl	3.1	goto userr;
110			if (i < argc) {
111			rval = viewfile(argv[i], &vw, &rs);
112			if (rval <= 0) {
113			fprintf(stderr, "%s: no view in picture\n", argv[i]);
114			exit(1);
115			}
116			if (i+1 < argc) {
117			zfd = open(argv[i+1], O_RDONLY);
118			if (zfd < 0) {
119			fprintf(stderr,
120			"%s: cannot open depth buffer\n",
121			argv[i+1]);
122			exit(1);
123			}
124			}
125			}
126			if ((err = setview(&vw)) != NULL) {
127			fprintf(stderr, "%s: %s\n", progname, err);
128			exit(1);
129			}
130			if (i == argc)
131			normaspect(viewaspect(&vw), &pa, &rs.xr, &rs.yr);
132			if (getdim) {
133	gregl	3.3	printf("-x %d -y %d -ld%c\n", rs.xr, rs.yr,
134			vw.vaft > FTINY ? '+' : '-');
135	gregl	3.1	exit(0);
136			}
137	greg	3.4	if (fromstdin)
138			pix2rays(stdin);
139			else
140			putrays();
141	gregl	3.1	exit(0);
142			userr:
143			fprintf(stderr,
144	greg	3.4	"Usage: %s [ -i -f{a\|f\|d} \| -d ] { view opts .. \| picture [zbuf] }\n",
145	gregl	3.1	progname);
146			exit(1);
147			}
148
149
150	schorsch	3.10	static void
151			pix2rays(
152			FILE *fp
153			)
154	greg	3.4	{
155			static FVECT rorg, rdir;
156			float zval;
157			double px, py;
158			int pp[2];
159			double d;
160			register int i;
161
162			while (fscanf(fp, "%lf %lf", &px, &py) == 2) {
163			if (px < 0 \|\| px >= rs.xr \|\|
164			py < 0 \|\| py >= rs.yr) {
165			fprintf(stderr,
166			"%s: (x,y) pair (%.0f,%.0f) out of range\n",
167			progname, px, py);
168			exit(1);
169			}
170			if (zfd >= 0) {
171			loc2pix(pp, &rs, px/rs.xr, py/rs.yr);
172			if (lseek(zfd,
173	greg	3.8	(pp[1]scanlen(&rs)+pp[0])sizeof(float),
174			SEEK_SET) < 0 \|\|
175	greg	3.4	read(zfd, &zval, sizeof(float))
176	greg	3.8	< sizeof(float)) {
177	greg	3.4	fprintf(stderr, "%s: depth buffer read error\n",
178			progname);
179			exit(1);
180			}
181			}
182			d = viewray(rorg, rdir, &vw, px/rs.xr, py/rs.yr);
183			if (d < -FTINY)
184			rorg[0] = rorg[1] = rorg[2] =
185			rdir[0] = rdir[1] = rdir[2] = 0.;
186			else if (zfd >= 0)
187			for (i = 0; i < 3; i++) {
188			rorg[i] += rdir[i]*zval;
189			rdir[i] = -rdir[i];
190			}
191			else if (d > FTINY) {
192			rdir[0] = d; rdir[1] = d; rdir[2] *= d;
193			}
194			(*putr)(rorg, rdir);
195			}
196			if (!feof(fp)) {
197			fprintf(stderr, "%s: expected px py on input\n", progname);
198			exit(1);
199			}
200			}
201
202
203	schorsch	3.10	static void
204			putrays(void)
205	gregl	3.1	{
206	schorsch	3.5	static RREAL loc[2];
207	gregl	3.2	static FVECT rorg, rdir;
208	schorsch	3.10	float *zbuf = NULL;
209	gregl	3.1	int sc;
210	gregl	3.2	double d;
211	gregl	3.1	register int si, i;
212
213			if (zfd >= 0) {
214			zbuf = (float )malloc(scanlen(&rs)sizeof(float));
215			if (zbuf == NULL) {
216			fprintf(stderr, "%s: not enough memory\n", progname);
217			exit(1);
218			}
219			}
220			for (sc = 0; sc < numscans(&rs); sc++) {
221			if (zfd >= 0) {
222			if (read(zfd, zbuf, scanlen(&rs)*sizeof(float)) <
223			scanlen(&rs)*sizeof(float)) {
224			fprintf(stderr, "%s: depth buffer read error\n",
225			progname);
226			exit(1);
227			}
228			}
229			for (si = 0; si < scanlen(&rs); si++) {
230			pix2loc(loc, &rs, si, sc);
231	gregl	3.2	d = viewray(rorg, rdir, &vw, loc[0], loc[1]);
232			if (d < -FTINY)
233	gregl	3.1	rorg[0] = rorg[1] = rorg[2] =
234			rdir[0] = rdir[1] = rdir[2] = 0.;
235			else if (zfd >= 0)
236			for (i = 0; i < 3; i++) {
237			rorg[i] += rdir[i]*zbuf[si];
238			rdir[i] = -rdir[i];
239			}
240	gregl	3.2	else if (d > FTINY) {
241			rdir[0] = d; rdir[1] = d; rdir[2] *= d;
242			}
243	gregl	3.1	(*putr)(rorg, rdir);
244			}
245			}
246			if (zfd >= 0)
247	greg	3.4	free((void *)zbuf);
248	gregl	3.1	}
249
250
251	schorsch	3.10	static void
252			puta( /* put out ray in ASCII format */
253			FVECT ro,
254			FVECT rd
255			)
256	gregl	3.1	{
257			printf("%.5e %.5e %.5e %.5e %.5e %.5e\n",
258			ro[0], ro[1], ro[2],
259			rd[0], rd[1], rd[2]);
260			}
261
262
263	schorsch	3.10	static void
264			putf( /* put out ray in float format */
265			FVECT ro,
266			FVECT rd
267			)
268	gregl	3.1	{
269			float v[6];
270
271			v[0] = ro[0]; v[1] = ro[1]; v[2] = ro[2];
272			v[3] = rd[0]; v[4] = rd[1]; v[5] = rd[2];
273			fwrite(v, sizeof(float), 6, stdout);
274			}
275
276
277	schorsch	3.10	static void
278			putd( /* put out ray in double format */
279			FVECT ro,
280			FVECT rd
281			)
282	gregl	3.1	{
283			double v[6];
284
285			v[0] = ro[0]; v[1] = ro[1]; v[2] = ro[2];
286			v[3] = rd[0]; v[4] = rd[1]; v[5] = rd[2];
287			fwrite(v, sizeof(double), 6, stdout);
288			}