src/util/vwrays.c

#ifndef lint
static const char       RCSid[] = "$Id: vwrays.c,v 3.25 2024/01/12 17:29:10 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.;

double  pd = 0.;

int     zfd = -1;

int     fromstdin = 0;

int     unbuffered = 0;

int     repeatcnt = 1;


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

        fixargv0(argv[0]);              /* sets global progname */
        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]);
                                        return(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);
                                return(1);
                        }
                        break;
                case 'y':                       /* y resolution */
                        rs.yr = atoi(argv[++i]);
                        if (rs.yr <= 0) {
                                fprintf(stderr, "%s: bad y resolution\n",
                                                progname);
                                return(1);
                        }
                        break;
                case 'c':                       /* repeat count */
                        repeatcnt = atoi(argv[++i]);
                        if (repeatcnt < 1) repeatcnt = 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 if (argv[i][2] == 'd')
                                pd = 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]);
                        return(1);
                }
                if (!getdim & (i+1 < argc)) {
                        zfd = open_float_depth(argv[i+1], (long)rs.xr*rs.yr);
                        if (zfd < 0)
                                return(1);
                }
        }
        if ((err = setview(&vw)) != NULL) {
                fprintf(stderr, "%s: %s\n", progname, err);
                return(1);
        }
        if (i == argc)
                normaspect(viewaspect(&vw), &pa, &rs.xr, &rs.yr);
        if (getdim) {
                printf("-x %d -y %d%s\n", rs.xr, rs.yr,
                                (vw.vaft > FTINY) ? " -ld+" : "");
                return(0);
        }
        if ((repeatcnt > 1) & (pj > FTINY))
                initurand(1024);
        if (fromstdin)
                pix2rays(stdin);
        else
                putrays();
        return(0);
userr:
        fprintf(stderr,
        "Usage: %s [ -i -u -f{a|f|d} -c rept | -d ] { view opts .. | picture [zbuf] }\n",
                        progname);
        return(1);
}


static void
jitterloc(
        RREAL   loc[2]
)
{
        static int      nsamp;
        double          xyr[2];

        if (pj <= FTINY)
                return;

        if (repeatcnt == 1) {
                xyr[0] = frandom();
                xyr[1] = frandom();
        } else                          /* stratify samples */
                multisamp(xyr, 2, urand(nsamp++));

        loc[0] += pj*(.5 - xyr[0])/rs.xr;
        loc[1] += pj*(.5 - xyr[1])/rs.yr;
}


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

        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) {
                        if ((loc[0] < 0) | (loc[0] >= 1) |
                                        (loc[1] < 0) | (loc[1] >= 1)) {
                                fprintf(stderr, "%s: input pixel outside image\n",
                                                progname);
                                exit(1);
                        }
                        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);
                        }
                }
                for (c = repeatcnt; c-- > 0; ) {
                        jitterloc(loc);
                        d = viewray(rorg, rdir, &vw, loc[0], loc[1]);
                        if (d < -FTINY || !jitteraperture(rorg, rdir, &vw, pd))
                                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 (c) {
                                loc[0] = px/rs.xr; loc[1] = py/rs.yr;
                        }
                }
                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;
        int     si, i, c;

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