src/util/vwrays.c

#ifndef lint
static const char       RCSid[] = "$Id: vwrays.c,v 3.15 2011/08/16 02:22:50 greg Exp $";
#endif
/*
 * Compute rays corresponding to a given picture or view.
 */

#include "platform.h"
#include "standard.h"
#include "random.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.;

double  pj = 0.;

int     zfd = -1;

int     fromstdin = 0;

int     unbuffered = 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;
                                SET_FILE_BINARY(stdout);
                                break;
                        case 'd':                       /* double */
                                putr = putd;
                                SET_FILE_BINARY(stdout);
                                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 or jitter */
                        if (argv[i][2] == 'a')
                                pa = atof(argv[++i]);
                        else if (argv[i][2] == 'j')
                                pj = atof(argv[++i]);
                        else
                                goto userr;
                        break;
                case 'i':                       /* get pixels from stdin */
                        fromstdin = 1;
                        break;
                case 'u':                       /* unbuffered output */
                        unbuffered = 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 -u -f{a|f|d} | -d ] { view opts .. | picture [zbuf] }\n",
                        progname);
        exit(1);
}


static void
jitterloc(
        RREAL   loc[2]
)
{
        if (pj > FTINY) {
                loc[0] += pj*(.5 - frandom())/rs.xr;
                loc[1] += pj*(.5 - frandom())/rs.yr;
        }
}


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

        while (fscanf(fp, "%lf %lf", &px, &py) == 2) {
                px += .5; py += .5;
                loc[0] = px/rs.xr; loc[1] = py/rs.yr;
                if (zfd >= 0) {
                        loc2pix(pp, &rs, loc[0], loc[1]);
                        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);
                        }
                }
                jitterloc(loc);
                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]*zval;
                                rdir[i] = -rdir[i];
                        }
                else if (d > FTINY) {
                        rdir[0] *= d; rdir[1] *= d; rdir[2] *= d;
                }
                (*putr)(rorg, rdir);
                if (unbuffered)
                        fflush(stdout);
        }
        if (!feof(fp)) {
                fprintf(stderr, "%s: expected px py on input\n", progname);
                exit(1);
        }
}


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