[ViewVC] Diff of: radiance/ray/src/px/pinterp.c

Comparing ray/src/px/pinterp.c (file contents):
Revision 1.14 by greg, Thu Jan 4 17:47:37 1990 UTC vs.
Revision 2.16 by greg, Fri Dec 23 15:42:55 1994 UTC

#	Line 1 \| Line 1
1	+	/* Copyright (c) 1994 Regents of the University of California */
2	+
3		#ifndef lint
4		static char SCCSid[] = "$SunId$ LBL";
5		#endif
#	Line 10 \| Line 12 \| static char SCCSid[] = "$SunId$ LBL";
12
13		#include "standard.h"
14
15	+	#include <ctype.h>
16	+
17		#include "view.h"
18
19		#include "color.h"
20
21	<	#define pscan(y) (ourpict+(y)*ourview.hresolu)
18	<	#define zscan(y) (ourzbuf+(y)*ourview.hresolu)
21	>	#include "resolu.h"
22
23	+	#define pscan(y) (ourpict+(y)*hresolu)
24	+	#define zscan(y) (ourzbuf+(y)*hresolu)
25	+
26		#define F_FORE 1 /* fill foreground */
27		#define F_BACK 2 /* fill background */
28
29	<	#define PACKSIZ 42 /* calculation packet size */
29	>	#define PACKSIZ 256 /* max. calculation packet size */
30
31	<	#define RTCOM "rtrace -h -ovl -fff -x %d %s"
31	>	#define RTCOM "rtrace -h- -ovl -fff "
32
33		#define ABS(x) ((x)>0?(x):-(x))
34
35	<	VIEW ourview = STDVIEW(512); /* desired view */
35	>	struct position {int x,y; float z;};
36
37	+	#define NSTEPS 64 /* number steps in overlap prescan */
38	+	#define MINSTEP 4 /* minimum worthwhile preview step */
39	+
40	+	struct bound {int min,max;};
41	+
42	+	VIEW ourview = STDVIEW; /* desired view */
43	+	int hresolu = 512; /* horizontal resolution */
44	+	int vresolu = 512; /* vertical resolution */
45	+	double pixaspect = 1.0; /* pixel aspect ratio */
46	+
47		double zeps = .02; /* allowed z epsilon */
48
49		COLR ourpict; / output picture */
#	Line 35 \| Line 51 \| *float ourzbuf; /* corresponding z-buffer /*
51
52		char *progname;
53
54	<	VIEW theirview = STDVIEW(512); /* input view */
55	<	int gotview; /* got input view? */
40	<
41	<	int fill = F_FORE\|F_BACK; /* selected fill algorithm */
54	>	int fillo = F_FORE\|F_BACK; /* selected fill options */
55	>	int fillsamp = 0; /* sample separation (0 == inf) */
56		extern int backfill(), rcalfill(); /* fill functions */
57	<	int (deffill)() = backfill; / selected fill function */
57	>	int (fillfunc)() = backfill; / selected fill function */
58		COLR backcolr = BLKCOLR; /* background color */
59		double backz = 0.0; /* background z value */
60	+	int normdist = 1; /* normalized distance? */
61	+	double ourexp = -1; /* output picture exposure */
62
63	+	VIEW theirview = STDVIEW; /* input view */
64	+	int gotview; /* got input view? */
65	+	int wrongformat = 0; /* input in another format? */
66	+	RESOLU tresolu; /* input resolution */
67	+	double theirexp; /* input picture exposure */
68		double theirs2ours[4][4]; /* transformation matrix */
69	<	int normdist = 1; /* normalized distance? */
69	>	int hasmatrix = 0; /* has transformation matrix */
70
71	<	int childpid = -1; /* id of fill process */
72	<	FILE psend, precv; /* pipes to/from fill calculation */
73	<	int queue[PACKSIZ][2]; /* pending pixels */
71	>	int PDesc[3] = {-1,-1,-1}; /* rtrace process descriptor */
72	>	#define childpid (PDesc[2])
73	>	unsigned short queue[PACKSIZ][2]; /* pending pixels */
74	>	int packsiz; /* actual packet size */
75		int queuesiz; /* number of pixels pending */
76
77
#	Line 57 \| Line 79 \| *main(argc, argv) / interpolate pictures /*
79		int argc;
80		char *argv[];
81		{
82	<	#define check(olen,narg) if (argv[i][olen] \|\| narg >= argc-i) goto badopt
83	<	extern double atof();
82	>	#define check(ol,al) if (argv[i][ol] \|\| \
83	>	badarg(argc-i-1,argv+i+1,al)) \
84	>	goto badopt
85		int gotvfile = 0;
86		char *zfile = NULL;
87		char *err;
88	<	int i;
88	>	int i, rval;
89
90		progname = argv[0];
91
92	<	for (i = 1; i < argc && argv[i][0] == '-'; i++)
92	>	for (i = 1; i < argc && argv[i][0] == '-'; i++) {
93	>	rval = getviewopt(&ourview, argc-i, argv+i);
94	>	if (rval >= 0) {
95	>	i += rval;
96	>	continue;
97	>	}
98		switch (argv[i][1]) {
99		case 't': /* threshold */
100	<	check(2,1);
100	>	check(2,"f");
101		zeps = atof(argv[++i]);
102		break;
103		case 'n': /* dist. normalized? */
104	<	check(2,0);
104	>	check(2,NULL);
105		normdist = !normdist;
106		break;
107		case 'f': /* fill type */
108		switch (argv[i][2]) {
109		case '0': /* none */
110	<	check(3,0);
111	<	fill = 0;
110	>	check(3,NULL);
111	>	fillo = 0;
112		break;
113		case 'f': /* foreground */
114	<	check(3,0);
115	<	fill = F_FORE;
114	>	check(3,NULL);
115	>	fillo = F_FORE;
116		break;
117		case 'b': /* background */
118	<	check(3,0);
119	<	fill = F_BACK;
118	>	check(3,NULL);
119	>	fillo = F_BACK;
120		break;
121		case 'a': /* all */
122	<	check(3,0);
123	<	fill = F_FORE\|F_BACK;
122	>	check(3,NULL);
123	>	fillo = F_FORE\|F_BACK;
124		break;
125	+	case 's': /* sample */
126	+	check(3,"i");
127	+	fillsamp = atoi(argv[++i]);
128	+	break;
129		case 'c': /* color */
130	<	check(3,3);
131	<	deffill = backfill;
130	>	check(3,"fff");
131	>	fillfunc = backfill;
132		setcolr(backcolr, atof(argv[i+1]),
133		atof(argv[i+2]), atof(argv[i+3]));
134		i += 3;
135		break;
136		case 'z': /* z value */
137	<	check(3,1);
138	<	deffill = backfill;
137	>	check(3,"f");
138	>	fillfunc = backfill;
139		backz = atof(argv[++i]);
140		break;
141		case 'r': /* rtrace */
142	<	check(3,1);
143	<	deffill = rcalfill;
142	>	check(3,"s");
143	>	fillfunc = rcalfill;
144		calstart(RTCOM, argv[++i]);
145		break;
146		default:
#	Line 116 \| Line 148 \| *char argv[];**
148		}
149		break;
150		case 'z': /* z file */
151	<	check(2,1);
151	>	check(2,"s");
152		zfile = argv[++i];
153		break;
154		case 'x': /* x resolution */
155	<	check(2,1);
156	<	ourview.hresolu = atoi(argv[++i]);
155	>	check(2,"i");
156	>	hresolu = atoi(argv[++i]);
157		break;
158		case 'y': /* y resolution */
159	<	check(2,1);
160	<	ourview.vresolu = atoi(argv[++i]);
159	>	check(2,"i");
160	>	vresolu = atoi(argv[++i]);
161		break;
162	<	case 'v': /* view */
163	<	switch (argv[i][2]) {
132	<	case 't': /* type */
133	<	check(4,0);
134	<	ourview.type = argv[i][3];
135	<	break;
136	<	case 'p': /* point */
137	<	check(3,3);
138	<	ourview.vp[0] = atof(argv[++i]);
139	<	ourview.vp[1] = atof(argv[++i]);
140	<	ourview.vp[2] = atof(argv[++i]);
141	<	break;
142	<	case 'd': /* direction */
143	<	check(3,3);
144	<	ourview.vdir[0] = atof(argv[++i]);
145	<	ourview.vdir[1] = atof(argv[++i]);
146	<	ourview.vdir[2] = atof(argv[++i]);
147	<	break;
148	<	case 'u': /* up */
149	<	check(3,3);
150	<	ourview.vup[0] = atof(argv[++i]);
151	<	ourview.vup[1] = atof(argv[++i]);
152	<	ourview.vup[2] = atof(argv[++i]);
153	<	break;
154	<	case 'h': /* horizontal */
155	<	check(3,1);
156	<	ourview.horiz = atof(argv[++i]);
157	<	break;
158	<	case 'v': /* vertical */
159	<	check(3,1);
160	<	ourview.vert = atof(argv[++i]);
161	<	break;
162	<	case 'f': /* file */
163	<	check(3,1);
164	<	gotvfile = viewfile(argv[++i], &ourview);
165	<	if (gotvfile < 0) {
166	<	perror(argv[i]);
167	<	exit(1);
168	<	} else if (gotvfile == 0) {
169	<	fprintf(stderr, "%s: bad view file\n",
170	<	argv[i]);
171	<	exit(1);
172	<	}
173	<	break;
174	<	default:
162	>	case 'p': /* pixel aspect */
163	>	if (argv[i][2] != 'a')
164		goto badopt;
165	+	check(3,"f");
166	+	pixaspect = atof(argv[++i]);
167	+	break;
168	+	case 'v': /* view file */
169	+	if (argv[i][2] != 'f')
170	+	goto badopt;
171	+	check(3,"s");
172	+	gotvfile = viewfile(argv[++i], &ourview, 0, 0);
173	+	if (gotvfile < 0)
174	+	syserror(argv[i]);
175	+	else if (gotvfile == 0) {
176	+	fprintf(stderr, "%s: bad view file\n",
177	+	argv[i]);
178	+	exit(1);
179		}
180		break;
181		default:
#	Line 181 \| Line 184 \| *char argv[];**
184		progname, argv[i]);
185		goto userr;
186		}
187	+	}
188		/* check arguments */
189		if ((argc-i)%2)
190		goto userr;
191	+	if (fillsamp == 1)
192	+	fillo &= ~F_BACK;
193		/* set view */
194	<	if (err = setview(&ourview)) {
194	>	if ((err = setview(&ourview)) != NULL) {
195		fprintf(stderr, "%s: %s\n", progname, err);
196		exit(1);
197		}
198	+	normaspect(viewaspect(&ourview), &pixaspect, &hresolu, &vresolu);
199		/* allocate frame */
200	<	ourpict = (COLR )malloc(ourview.hresoluourview.vresolu*sizeof(COLR));
201	<	ourzbuf = (float )calloc(ourview.hresoluourview.vresolu,sizeof(float));
202	<	if (ourpict == NULL \|\| ourzbuf == NULL) {
203	<	perror(progname);
204	<	exit(1);
205	<	}
200	>	ourpict = (COLR )bmalloc(hresoluvresolu*sizeof(COLR));
201	>	ourzbuf = (float )bmalloc(hresoluvresolu*sizeof(float));
202	>	if (ourpict == NULL \|\| ourzbuf == NULL)
203	>	syserror(progname);
204	>	bzero((char )ourzbuf, hresoluvresolu*sizeof(float));
205	>	/* new header */
206	>	newheader("RADIANCE", stdout);
207		/* get input */
208		for ( ; i < argc; i += 2)
209		addpicture(argv[i], argv[i+1]);
210		/* fill in spaces */
211	<	if (fill&F_BACK)
212	<	backpicture();
211	>	if (fillo&F_BACK)
212	>	backpicture(fillfunc, fillsamp);
213		else
214	<	fillpicture();
214	>	fillpicture(fillfunc);
215		/* close calculation */
216		caldone();
217	+	/* aft clipping */
218	+	clipaft();
219		/* add to header */
220		printargs(argc, argv, stdout);
221		if (gotvfile) {
222	<	printf(VIEWSTR);
222	>	fputs(VIEWSTR, stdout);
223		fprintview(&ourview, stdout);
224	<	printf("\n");
224	>	putc('\n', stdout);
225		}
226	<	printf("\n");
226	>	if (pixaspect < .99 \|\| pixaspect > 1.01)
227	>	fputaspect(pixaspect, stdout);
228	>	if (ourexp > 0 && (ourexp < .995 \|\| ourexp > 1.005))
229	>	fputexpos(ourexp, stdout);
230	>	fputformat(COLRFMT, stdout);
231	>	putc('\n', stdout);
232		/* write picture */
233		writepicture();
234		/* write z file */
#	Line 223 \| Line 238 \| *char argv[];**
238		exit(0);
239		userr:
240		fprintf(stderr,
241	<	"Usage: %s [view opts][-t zthresh][-z zout][-fT][-n] pfile zspec ..\n",
241	>	"Usage: %s [view opts][-t eps][-z zout][-fT][-n] pfile zspec ..\n",
242		progname);
243		exit(1);
244		#undef check
#	Line 233 \| Line 248 \| userr:
248		headline(s) /* process header string */
249		char *s;
250		{
251	<	static char *altname[] = {"rview","rpict","pinterp",VIEWSTR,NULL};
237	<	register char **an;
251	>	char fmt[32];
252
253	<	printf("\t%s", s);
253	>	if (isheadid(s))
254	>	return;
255	>	if (formatval(fmt, s)) {
256	>	wrongformat = strcmp(fmt, COLRFMT);
257	>	return;
258	>	}
259	>	putc('\t', stdout);
260	>	fputs(s, stdout);
261
262	<	for (an = altname; *an != NULL; an++)
263	<	if (!strncmp(an, s, strlen(an))) {
264	<	if (sscanview(&theirview, s+strlen(*an)) == 0)
265	<	gotview++;
266	<	break;
267	<	}
262	>	if (isexpos(s)) {
263	>	theirexp *= exposval(s);
264	>	return;
265	>	}
266	>	if (isview(s) && sscanview(&theirview, s) > 0)
267	>	gotview++;
268		}
269
270
271		addpicture(pfile, zspec) /* add picture to output */
272		char pfile, zspec;
273		{
274	<	extern double atof();
275	<	FILE pfp, zfp;
274	>	FILE *pfp;
275	>	int zfd;
276		char *err;
277		COLR *scanin;
278	<	float zin, zlast;
279	<	int *plast;
278	>	float *zin;
279	>	struct position *plast;
280	>	struct bound *xlim, ylim;
281		int y;
282		/* open picture file */
283	<	if ((pfp = fopen(pfile, "r")) == NULL) {
284	<	perror(pfile);
285	<	exit(1);
286	<	}
265	<	/* get header and view */
266	<	printf("%s:\n", pfile);
283	>	if ((pfp = fopen(pfile, "r")) == NULL)
284	>	syserror(pfile);
285	>	/* get header with exposure and view */
286	>	theirexp = 1.0;
287		gotview = 0;
288	<	getheader(pfp, headline);
289	<	if (!gotview \|\| fgetresolu(&theirview.hresolu, &theirview.vresolu, pfp)
290	<	!= (YMAJOR\|YDECR)) {
291	<	fprintf(stderr, "%s: picture view error\n", pfile);
288	>	printf("%s:\n", pfile);
289	>	getheader(pfp, headline, NULL);
290	>	if (wrongformat \|\| !gotview \|\| !fgetsresolu(&tresolu, pfp)) {
291	>	fprintf(stderr, "%s: picture format error\n", pfile);
292		exit(1);
293		}
294	+	if (ourexp <= 0)
295	+	ourexp = theirexp;
296	+	else if (ABS(theirexp-ourexp) > .01*ourexp)
297	+	fprintf(stderr, "%s: different exposure (warning)\n", pfile);
298		if (err = setview(&theirview)) {
299		fprintf(stderr, "%s: %s\n", pfile, err);
300		exit(1);
301		}
302		/* compute transformation */
303	<	pixform(theirs2ours, &theirview, &ourview);
280	<	/* allocate scanlines */
281	<	scanin = (COLR )malloc(theirview.hresolusizeof(COLR));
282	<	zin = (float )malloc(theirview.hresolusizeof(float));
283	<	plast = (int *)calloc(theirview.hresolu, sizeof(int));
284	<	zlast = (float *)calloc(theirview.hresolu, sizeof(float));
285	<	if (scanin == NULL \|\| zin == NULL \|\| plast == NULL \|\| zlast == NULL) {
286	<	perror(progname);
287	<	exit(1);
288	<	}
303	>	hasmatrix = pixform(theirs2ours, &theirview, &ourview);
304		/* get z specification or file */
305	<	if ((zfp = fopen(zspec, "r")) == NULL) {
305	>	zin = (float )malloc(scanlen(&tresolu)sizeof(float));
306	>	if (zin == NULL)
307	>	syserror(progname);
308	>	if ((zfd = open(zspec, O_RDONLY)) == -1) {
309		double zvalue;
310		register int x;
311	<	if (!isfloat(zspec) \|\| (zvalue = atof(zspec)) <= 0.0) {
312	<	perror(zspec);
313	<	exit(1);
296	<	}
297	<	for (x = 0; x < theirview.hresolu; x++)
311	>	if (!isfloat(zspec) \|\| (zvalue = atof(zspec)) <= 0.0)
312	>	syserror(zspec);
313	>	for (x = scanlen(&tresolu); x-- > 0; )
314		zin[x] = zvalue;
315		}
316	<	/* load image */
317	<	for (y = theirview.vresolu-1; y >= 0; y--) {
318	<	if (freadcolrs(scanin, theirview.hresolu, pfp) < 0) {
316	>	/* compute transferrable perimeter */
317	>	xlim = (struct bound )malloc(numscans(&tresolu)sizeof(struct bound));
318	>	if (xlim == NULL)
319	>	syserror(progname);
320	>	if (!getperim(xlim, &ylim, zin, zfd)) { /* overlapping area? */
321	>	free((char *)zin);
322	>	free((char *)xlim);
323	>	if (zfd != -1)
324	>	close(zfd);
325	>	fclose(pfp);
326	>	return;
327	>	}
328	>	/* allocate scanlines */
329	>	scanin = (COLR )malloc(scanlen(&tresolu)sizeof(COLR));
330	>	plast = (struct position *)calloc(scanlen(&tresolu),
331	>	sizeof(struct position));
332	>	if (scanin == NULL \| plast == NULL)
333	>	syserror(progname);
334	>	/* skip to starting point */
335	>	for (y = 0; y < ylim.min; y++)
336	>	if (freadcolrs(scanin, scanlen(&tresolu), pfp) < 0) {
337		fprintf(stderr, "%s: read error\n", pfile);
338		exit(1);
339		}
340	<	if (zfp != NULL
341	<	&& fread(zin,sizeof(float),theirview.hresolu,zfp)
342	<	< theirview.hresolu) {
343	<	fprintf(stderr, "%s: read error\n", zspec);
340	>	if (zfd != -1 && lseek(zfd,
341	>	(long)ylim.minscanlen(&tresolu)sizeof(float), 0) < 0)
342	>	syserror(zspec);
343	>	/* load image */
344	>	for (y = ylim.min; y <= ylim.max; y++) {
345	>	if (freadcolrs(scanin, scanlen(&tresolu), pfp) < 0) {
346	>	fprintf(stderr, "%s: read error\n", pfile);
347		exit(1);
348		}
349	<	addscanline(y, scanin, zin, plast, zlast);
349	>	if (zfd != -1 && read(zfd, (char *)zin,
350	>	scanlen(&tresolu)*sizeof(float))
351	>	< scanlen(&tresolu)*sizeof(float))
352	>	syserror(zspec);
353	>	addscanline(xlim+y, y, scanin, zin, plast);
354		}
355		/* clean up */
356	+	free((char *)xlim);
357		free((char *)scanin);
358		free((char *)zin);
359		free((char *)plast);
318	–	free((char *)zlast);
360		fclose(pfp);
361	<	if (zfp != NULL)
362	<	fclose(zfp);
361	>	if (zfd != -1)
362	>	close(zfd);
363		}
364
365
#	Line 328 \| Line 369 \| *register VIEW vw1, vw2;*
369		{
370		double m4t[4][4];
371
372	+	if (vw1->type != VT_PER && vw1->type != VT_PAR)
373	+	return(0);
374	+	if (vw2->type != VT_PER && vw2->type != VT_PAR)
375	+	return(0);
376		setident4(xfmat);
377	<	xfmat[0][0] = vw1->vhinc[0];
378	<	xfmat[0][1] = vw1->vhinc[1];
379	<	xfmat[0][2] = vw1->vhinc[2];
380	<	xfmat[1][0] = vw1->vvinc[0];
381	<	xfmat[1][1] = vw1->vvinc[1];
382	<	xfmat[1][2] = vw1->vvinc[2];
377	>	xfmat[0][0] = vw1->hvec[0];
378	>	xfmat[0][1] = vw1->hvec[1];
379	>	xfmat[0][2] = vw1->hvec[2];
380	>	xfmat[1][0] = vw1->vvec[0];
381	>	xfmat[1][1] = vw1->vvec[1];
382	>	xfmat[1][2] = vw1->vvec[2];
383		xfmat[2][0] = vw1->vdir[0];
384		xfmat[2][1] = vw1->vdir[1];
385		xfmat[2][2] = vw1->vdir[2];
#	Line 342 \| Line 387 \| *register VIEW vw1, vw2;*
387		xfmat[3][1] = vw1->vp[1];
388		xfmat[3][2] = vw1->vp[2];
389		setident4(m4t);
390	<	m4t[0][0] = vw2->vhinc[0]/vw2->vhn2;
391	<	m4t[1][0] = vw2->vhinc[1]/vw2->vhn2;
392	<	m4t[2][0] = vw2->vhinc[2]/vw2->vhn2;
393	<	m4t[3][0] = -DOT(vw2->vp,vw2->vhinc)/vw2->vhn2;
394	<	m4t[0][1] = vw2->vvinc[0]/vw2->vvn2;
395	<	m4t[1][1] = vw2->vvinc[1]/vw2->vvn2;
396	<	m4t[2][1] = vw2->vvinc[2]/vw2->vvn2;
397	<	m4t[3][1] = -DOT(vw2->vp,vw2->vvinc)/vw2->vvn2;
390	>	m4t[0][0] = vw2->hvec[0]/vw2->hn2;
391	>	m4t[1][0] = vw2->hvec[1]/vw2->hn2;
392	>	m4t[2][0] = vw2->hvec[2]/vw2->hn2;
393	>	m4t[3][0] = -DOT(vw2->vp,vw2->hvec)/vw2->hn2;
394	>	m4t[0][1] = vw2->vvec[0]/vw2->vn2;
395	>	m4t[1][1] = vw2->vvec[1]/vw2->vn2;
396	>	m4t[2][1] = vw2->vvec[2]/vw2->vn2;
397	>	m4t[3][1] = -DOT(vw2->vp,vw2->vvec)/vw2->vn2;
398		m4t[0][2] = vw2->vdir[0];
399		m4t[1][2] = vw2->vdir[1];
400		m4t[2][2] = vw2->vdir[2];
401		m4t[3][2] = -DOT(vw2->vp,vw2->vdir);
402		multmat4(xfmat, xfmat, m4t);
403	+	return(1);
404		}
405
406
407	<	addscanline(y, pline, zline, lasty, lastyz) /* add scanline to output */
407	>	addscanline(xl, y, pline, zline, lasty) /* add scanline to output */
408	>	struct bound *xl;
409		int y;
410		COLR *pline;
411		float *zline;
412	<	int lasty; / input/output */
366	<	float lastyz; / input/output */
412	>	struct position lasty; / input/output */
413		{
414	<	extern double sqrt();
415	<	double pos[3];
370	<	int lastx = 0;
371	<	double lastxz = 0;
372	<	double zt;
373	<	int xpos, ypos;
414	>	FVECT pos;
415	>	struct position lastx, newpos;
416		register int x;
417
418	<	for (x = theirview.hresolu-1; x >= 0; x--) {
419	<	pos[0] = x - .5*(theirview.hresolu-1);
420	<	pos[1] = y - .5*(theirview.vresolu-1);
418	>	lastx.z = 0;
419	>	for (x = xl->max; x >= xl->min; x--) {
420	>	pix2loc(pos, &tresolu, x, y);
421		pos[2] = zline[x];
422	<	if (theirview.type == VT_PER) {
423	<	if (normdist) /* adjust for eye-ray distance */
382	<	pos[2] /= sqrt( 1.
383	<	+ pos[0]pos[0]theirview.vhn2
384	<	+ pos[1]pos[1]theirview.vvn2 );
385	<	pos[0] *= pos[2];
386	<	pos[1] *= pos[2];
387	<	}
388	<	multp3(pos, pos, theirs2ours);
389	<	if (pos[2] <= 0)
422	>	if (movepixel(pos) < 0) {
423	>	lasty[x].z = lastx.z = 0; /* mark invalid */
424		continue;
391	–	if (ourview.type == VT_PER) {
392	–	pos[0] /= pos[2];
393	–	pos[1] /= pos[2];
425		}
426	<	pos[0] += .5*ourview.hresolu;
427	<	pos[1] += .5*ourview.vresolu;
428	<	if (pos[0] < 0 \|\| (xpos = pos[0]) >= ourview.hresolu
398	<	\|\| pos[1] < 0 \|\| (ypos = pos[1]) >= ourview.vresolu)
399	<	continue;
426	>	newpos.x = pos[0] * hresolu;
427	>	newpos.y = pos[1] * vresolu;
428	>	newpos.z = zline[x];
429		/* add pixel to our image */
430	<	zt = 2.zepszline[x];
431	<	addpixel(xpos, ypos,
432	<	(fill&F_FORE && ABS(zline[x]-lastxz) <= zt)
433	<	? lastx - xpos : 1,
434	<	(fill&F_FORE && ABS(zline[x]-lastyz[x]) <= zt)
435	<	? lasty[x] - ypos : 1,
436	<	pline[x], pos[2]);
437	<	lastx = xpos;
409	<	lasty[x] = ypos;
410	<	lastxz = lastyz[x] = zline[x];
430	>	if (pos[0] >= 0 && newpos.x < hresolu
431	>	&& pos[1] >= 0 && newpos.y < vresolu) {
432	>	addpixel(&newpos, &lastx, &lasty[x], pline[x], pos[2]);
433	>	lasty[x].x = lastx.x = newpos.x;
434	>	lasty[x].y = lastx.y = newpos.y;
435	>	lasty[x].z = lastx.z = newpos.z;
436	>	} else
437	>	lasty[x].z = lastx.z = 0; /* mark invalid */
438		}
439		}
440
441
442	<	addpixel(xstart, ystart, width, height, pix, z) /* fill in area for pixel */
443	<	int xstart, ystart;
417	<	int width, height;
442	>	addpixel(p0, p1, p2, pix, z) /* fill in pixel parallelogram */
443	>	struct position p0, p1, *p2;
444		COLR pix;
445		double z;
446		{
447	<	register int x, y;
448	<	/* make width and height positive */
449	<	if (width < 0) {
450	<	width = -width;
451	<	xstart = xstart-width+1;
452	<	} else if (width == 0)
453	<	width = 1;
454	<	if (height < 0) {
455	<	height = -height;
456	<	ystart = ystart-height+1;
457	<	} else if (height == 0)
458	<	height = 1;
459	<	/* fill pixel(s) within rectangle */
460	<	for (y = ystart; y < ystart+height; y++)
461	<	for (x = xstart; x < xstart+width; x++)
462	<	if (zscan(y)[x] <= 0
463	<	\|\| zscan(y)[x]-z > zeps*zscan(y)[x]) {
447	>	double zt = 2.zepsp0->z; /* threshold */
448	>	int s1x, s1y, s2x, s2y; /* step sizes */
449	>	int l1, l2, c1, c2; /* side lengths and counters */
450	>	int p1isy; /* p0p1 along y? */
451	>	int x1, y1; /* p1 position */
452	>	register int x, y; /* final position */
453	>
454	>	/* compute vector p0p1 */
455	>	if (fillo&F_FORE && ABS(p1->z-p0->z) <= zt) {
456	>	s1x = p1->x - p0->x;
457	>	s1y = p1->y - p0->y;
458	>	l1 = ABS(s1x);
459	>	if (p1isy = (ABS(s1y) > l1))
460	>	l1 = ABS(s1y);
461	>	} else {
462	>	l1 = s1x = s1y = 1;
463	>	p1isy = -1;
464	>	}
465	>	/* compute vector p0p2 */
466	>	if (fillo&F_FORE && ABS(p2->z-p0->z) <= zt) {
467	>	s2x = p2->x - p0->x;
468	>	s2y = p2->y - p0->y;
469	>	if (p1isy == 1)
470	>	l2 = ABS(s2x);
471	>	else {
472	>	l2 = ABS(s2y);
473	>	if (p1isy != 0 && ABS(s2x) > l2)
474	>	l2 = ABS(s2x);
475	>	}
476	>	} else
477	>	l2 = s2x = s2y = 1;
478	>	/* fill the parallelogram */
479	>	for (c1 = l1; c1-- > 0; ) {
480	>	x1 = p0->x + c1*s1x/l1;
481	>	y1 = p0->y + c1*s1y/l1;
482	>	for (c2 = l2; c2-- > 0; ) {
483	>	x = x1 + c2*s2x/l2;
484	>	if (x < 0 \|\| x >= hresolu)
485	>	continue;
486	>	y = y1 + c2*s2y/l2;
487	>	if (y < 0 \|\| y >= vresolu)
488	>	continue;
489	>	if (zscan(y)[x] <= 0 \|\| zscan(y)[x]-z
490	>	> zeps*zscan(y)[x]) {
491		zscan(y)[x] = z;
492		copycolr(pscan(y)[x], pix);
493		}
494	+	}
495	+	}
496		}
497
498
499	<	backpicture() /* background fill algorithm */
499	>	getperim(xl, yl, zline, zfd) /* compute overlapping image area */
500	>	register struct bound *xl;
501	>	struct bound *yl;
502	>	float *zline;
503	>	int zfd;
504		{
505	+	int step;
506	+	FVECT pos;
507	+	register int x, y;
508	+	/* set up step size */
509	+	if (scanlen(&tresolu) < numscans(&tresolu))
510	+	step = scanlen(&tresolu)/NSTEPS;
511	+	else
512	+	step = numscans(&tresolu)/NSTEPS;
513	+	if (step < MINSTEP) { /* not worth cropping? */
514	+	yl->min = 0;
515	+	yl->max = numscans(&tresolu) - 1;
516	+	x = scanlen(&tresolu) - 1;
517	+	for (y = numscans(&tresolu); y--; ) {
518	+	xl[y].min = 0;
519	+	xl[y].max = x;
520	+	}
521	+	return(1);
522	+	}
523	+	yl->min = 32000; yl->max = 0; /* search for points on image */
524	+	for (y = step - 1; y < numscans(&tresolu); y += step) {
525	+	if (zfd != -1) {
526	+	if (lseek(zfd, (long)yscanlen(&tresolu)sizeof(float),
527	+	0) < 0)
528	+	syserror("lseek");
529	+	if (read(zfd, (char *)zline,
530	+	scanlen(&tresolu)*sizeof(float))
531	+	< scanlen(&tresolu)*sizeof(float))
532	+	syserror("read");
533	+	}
534	+	xl[y].min = 32000; xl[y].max = 0; /* x max */
535	+	for (x = scanlen(&tresolu); (x -= step) > 0; ) {
536	+	pix2loc(pos, &tresolu, x, y);
537	+	pos[2] = zline[x];
538	+	if (movepixel(pos) == 0 && pos[0] >= 0 &&
539	+	pos[0] < 1 && pos[1] >= 0 &&
540	+	pos[1] < 1) {
541	+	xl[y].max = x + step - 1;
542	+	xl[y].min = x - step + 1; /* x min */
543	+	if (xl[y].min < 0)
544	+	xl[y].min = 0;
545	+	for (x = step - 1; x < xl[y].max; x += step) {
546	+	pix2loc(pos, &tresolu, x, y);
547	+	pos[2] = zline[x];
548	+	if (movepixel(pos) == 0 &&
549	+	pos[0] >= 0 &&
550	+	pos[0] < 1 &&
551	+	pos[1] >= 0 &&
552	+	pos[1] < 1) {
553	+	xl[y].min = x - step + 1;
554	+	break;
555	+	}
556	+	}
557	+	if (y < yl->min) /* y limits */
558	+	yl->min = y - step + 1;
559	+	yl->max = y + step - 1;
560	+	break;
561	+	}
562	+	}
563	+	/* fill in between */
564	+	if (xl[y].min < xl[y-step].min)
565	+	xl[y-1].min = xl[y].min;
566	+	else
567	+	xl[y-1].min = xl[y-step].min;
568	+	if (xl[y].max > xl[y-step].max)
569	+	xl[y-1].max = xl[y].max;
570	+	else
571	+	xl[y-1].max = xl[y-step].max;
572	+	for (x = 2; x < step; x++)
573	+	copystruct(xl+y-x, xl+y-1);
574	+	}
575	+	if (yl->max >= numscans(&tresolu))
576	+	yl->max = numscans(&tresolu) - 1;
577	+	for (x = numscans(&tresolu) - 1; x > y; x--) /* fill bottom rows */
578	+	copystruct(xl+x, xl+y);
579	+	return(yl->max >= yl->min);
580	+	}
581	+
582	+
583	+	movepixel(pos) /* reposition image point */
584	+	FVECT pos;
585	+	{
586	+	double d0, d1;
587	+	FVECT pt, direc;
588	+
589	+	if (pos[2] <= 0) /* empty pixel */
590	+	return(-1);
591	+	if (normdist && theirview.type == VT_PER) { /* adjust distance */
592	+	d0 = pos[0] + theirview.hoff - .5;
593	+	d1 = pos[1] + theirview.voff - .5;
594	+	pos[2] /= sqrt(1. + d0d0theirview.hn2 + d1d1theirview.vn2);
595	+	}
596	+	if (hasmatrix) {
597	+	pos[0] += theirview.hoff - .5;
598	+	pos[1] += theirview.voff - .5;
599	+	if (theirview.type == VT_PER) {
600	+	pos[0] *= pos[2];
601	+	pos[1] *= pos[2];
602	+	}
603	+	multp3(pos, pos, theirs2ours);
604	+	if (pos[2] <= 0)
605	+	return(-1);
606	+	if (ourview.type == VT_PER) {
607	+	pos[0] /= pos[2];
608	+	pos[1] /= pos[2];
609	+	}
610	+	pos[0] += .5 - ourview.hoff;
611	+	pos[1] += .5 - ourview.voff;
612	+	return(0);
613	+	}
614	+	if (viewray(pt, direc, &theirview, pos[0], pos[1]) < -FTINY)
615	+	return(-1);
616	+	pt[0] += direc[0]*pos[2];
617	+	pt[1] += direc[1]*pos[2];
618	+	pt[2] += direc[2]*pos[2];
619	+	viewloc(pos, &ourview, pt);
620	+	if (pos[2] <= 0)
621	+	return(-1);
622	+	return(0);
623	+	}
624	+
625	+
626	+	backpicture(fill, samp) /* background fill algorithm */
627	+	int (*fill)();
628	+	int samp;
629	+	{
630		int *yback, xback;
631		int y;
448	–	COLR pfill;
632		register int x, i;
633		/* get back buffer */
634	<	yback = (int )malloc(ourview.hresolusizeof(int));
635	<	if (yback == NULL) {
636	<	perror(progname);
637	<	return;
455	<	}
456	<	for (x = 0; x < ourview.hresolu; x++)
634	>	yback = (int )malloc(hresolusizeof(int));
635	>	if (yback == NULL)
636	>	syserror(progname);
637	>	for (x = 0; x < hresolu; x++)
638		yback[x] = -2;
639		/*
640		* Xback and yback are the pixel locations of suitable
#	Line 462 \| Line 643 \| *backpicture() / background fill algorithm /*
643		* that there is no suitable background in this direction.
644		*/
645		/* fill image */
646	<	for (y = 0; y < ourview.vresolu; y++) {
646	>	for (y = 0; y < vresolu; y++) {
647		xback = -2;
648	<	for (x = 0; x < ourview.hresolu; x++)
648	>	for (x = 0; x < hresolu; x++)
649		if (zscan(y)[x] <= 0) { /* empty pixel */
650		/*
651		* First, find background from above or below.
652		* (farthest assigned pixel)
653		*/
654		if (yback[x] == -2) {
655	<	for (i = y+1; i < ourview.vresolu; i++)
655	>	for (i = y+1; i < vresolu; i++)
656		if (zscan(i)[x] > 0)
657		break;
658	<	if (i < ourview.vresolu
658	>	if (i < vresolu
659		&& (y <= 0 \|\| zscan(y-1)[x] < zscan(i)[x]))
660		yback[x] = i;
661		else
#	Line 484 \| Line 665 \| *backpicture() / background fill algorithm /*
665		* Next, find background from left or right.
666		*/
667		if (xback == -2) {
668	<	for (i = x+1; i < ourview.hresolu; i++)
668	>	for (i = x+1; i < hresolu; i++)
669		if (zscan(y)[i] > 0)
670		break;
671	<	if (i < ourview.hresolu
671	>	if (i < hresolu
672		&& (x <= 0 \|\| zscan(y)[x-1] < zscan(y)[i]))
673		xback = i;
674		else
675		xback = x-1;
676		}
677		/*
678	<	* Check to see if we have no background for
679	<	* this pixel. If not, use background color.
678	>	* If we have no background for this pixel,
679	>	* use the given fill function.
680		*/
681	<	if (xback < 0 && yback[x] < 0) {
682	<	(*deffill)(x,y);
502	<	continue;
503	<	}
681	>	if (xback < 0 && yback[x] < 0)
682	>	goto fillit;
683		/*
684		* Compare, and use the background that is
685		* farther, unless one of them is next to us.
686	+	* If the background is too distant, call
687	+	* the fill function.
688		*/
689		if ( yback[x] < 0
690		\|\| (xback >= 0 && ABS(x-xback) <= 1)
691		\|\| ( ABS(y-yback[x]) > 1
692		&& zscan(yback[x])[x]
693		< zscan(y)[xback] ) ) {
694	+	if (samp > 0 && ABS(x-xback) >= samp)
695	+	goto fillit;
696		copycolr(pscan(y)[x],pscan(y)[xback]);
697		zscan(y)[x] = zscan(y)[xback];
698		} else {
699	+	if (samp > 0 && ABS(y-yback[x]) > samp)
700	+	goto fillit;
701		copycolr(pscan(y)[x],pscan(yback[x])[x]);
702		zscan(y)[x] = zscan(yback[x])[x];
703		}
704	+	continue;
705	+	fillit:
706	+	(*fill)(x,y);
707	+	if (fill == rcalfill) { /* use it */
708	+	clearqueue();
709	+	xback = x;
710	+	yback[x] = y;
711	+	}
712		} else { /* full pixel */
713		yback[x] = -2;
714		xback = -2;
#	Line 525 \| Line 718 \| *backpicture() / background fill algorithm /*
718		}
719
720
721	<	fillpicture() /* paint in empty pixels with default */
721	>	fillpicture(fill) /* paint in empty pixels using fill */
722	>	int (*fill)();
723		{
724		register int x, y;
725
726	<	for (y = 0; y < ourview.vresolu; y++)
727	<	for (x = 0; x < ourview.hresolu; x++)
726	>	for (y = 0; y < vresolu; y++)
727	>	for (x = 0; x < hresolu; x++)
728		if (zscan(y)[x] <= 0)
729	<	(*deffill)(x,y);
729	>	(*fill)(x,y);
730		}
731
732
733	+	clipaft() /* perform aft clipping as indicated */
734	+	{
735	+	register int x, y;
736	+	double tstdist;
737	+	double yzn2, vx;
738	+
739	+	if (ourview.vaft <= FTINY)
740	+	return;
741	+	tstdist = ourview.vaft;
742	+	for (y = 0; y < vresolu; y++) {
743	+	if (ourview.type == VT_PER) { /* adjust distance */
744	+	yzn2 = (y+.5)/vresolu + ourview.voff - .5;
745	+	yzn2 = 1. + yzn2yzn2ourview.vn2;
746	+	tstdist = ourview.vaft * sqrt(yzn2);
747	+	}
748	+	for (x = 0; x < hresolu; x++)
749	+	if (zscan(y)[x] > tstdist) {
750	+	if (ourview.type == VT_PER) {
751	+	vx = (x+.5)/hresolu + ourview.hoff - .5;
752	+	if (zscan(y)[x] <= ourview.vaft *
753	+	sqrt(vxvxourview.hn2 + yzn2))
754	+	continue;
755	+	}
756	+	bzero(pscan(y)[x], sizeof(COLR));
757	+	zscan(y)[x] = 0.0;
758	+	}
759	+	}
760	+	}
761	+
762	+
763		writepicture() /* write out picture */
764		{
765		int y;
766
767	<	fputresolu(YMAJOR\|YDECR, ourview.hresolu, ourview.vresolu, stdout);
768	<	for (y = ourview.vresolu-1; y >= 0; y--)
769	<	if (fwritecolrs(pscan(y), ourview.hresolu, stdout) < 0) {
770	<	perror(progname);
547	<	exit(1);
548	<	}
767	>	fprtresolu(hresolu, vresolu, stdout);
768	>	for (y = vresolu-1; y >= 0; y--)
769	>	if (fwritecolrs(pscan(y), hresolu, stdout) < 0)
770	>	syserror(progname);
771		}
772
773
774		writedistance(fname) /* write out z file */
775		char *fname;
776		{
555	–	extern double sqrt();
777		int donorm = normdist && ourview.type == VT_PER;
778	<	FILE *fp;
778	>	int fd;
779		int y;
780		float *zout;
781
782	<	if ((fp = fopen(fname, "w")) == NULL) {
783	<	perror(fname);
563	<	exit(1);
564	<	}
782	>	if ((fd = open(fname, O_WRONLY\|O_CREAT\|O_TRUNC, 0666)) == -1)
783	>	syserror(fname);
784		if (donorm
785	<	&& (zout = (float )malloc(ourview.hresolusizeof(float))) == NULL) {
786	<	perror(progname);
787	<	exit(1);
569	<	}
570	<	for (y = ourview.vresolu-1; y >= 0; y--) {
785	>	&& (zout = (float )malloc(hresolusizeof(float))) == NULL)
786	>	syserror(progname);
787	>	for (y = vresolu-1; y >= 0; y--) {
788		if (donorm) {
789		double vx, yzn2;
790		register int x;
791	<	yzn2 = y - .5*(ourview.vresolu-1);
792	<	yzn2 = 1. + yzn2yzn2ourview.vvn2;
793	<	for (x = 0; x < ourview.hresolu; x++) {
794	<	vx = x - .5*(ourview.hresolu-1);
791	>	yzn2 = (y+.5)/vresolu + ourview.voff - .5;
792	>	yzn2 = 1. + yzn2yzn2ourview.vn2;
793	>	for (x = 0; x < hresolu; x++) {
794	>	vx = (x+.5)/hresolu + ourview.hoff - .5;
795		zout[x] = zscan(y)[x]
796	<	* sqrt(vxvxourview.vhn2 + yzn2);
796	>	* sqrt(vxvxourview.hn2 + yzn2);
797		}
798		} else
799		zout = zscan(y);
800	<	if (fwrite(zout, sizeof(float), ourview.hresolu, fp)
801	<	< ourview.hresolu) {
802	<	perror(fname);
586	<	exit(1);
587	<	}
800	>	if (write(fd, (char )zout, hresolusizeof(float))
801	>	< hresolu*sizeof(float))
802	>	syserror(fname);
803		}
804		if (donorm)
805		free((char *)zout);
806	<	fclose(fp);
806	>	close(fd);
807		}
808
809
#	Line 613 \| Line 828 \| int x, y;
828		}
829
830
831	<	calstart(prog, args) /* start fill calculation */
831	>	calstart(prog, args) /* start fill calculation */
832		char prog, args;
833		{
834		char combuf[512];
835	<	int p0[2], p1[2];
835	>	char *argv[64];
836	>	int rval;
837	>	register char *wp, cp;
838
839		if (childpid != -1) {
840		fprintf(stderr, "%s: too many calculations\n", progname);
841		exit(1);
842		}
843	<	sprintf(combuf, prog, PACKSIZ, args);
844	<	if (pipe(p0) < 0 \|\| pipe(p1) < 0)
845	<	syserror();
846	<	if ((childpid = vfork()) == 0) { /* fork calculation */
847	<	close(p0[1]);
848	<	close(p1[0]);
849	<	if (p0[0] != 0) {
850	<	dup2(p0[0], 0);
851	<	close(p0[0]);
852	<	}
853	<	if (p1[1] != 1) {
854	<	dup2(p1[1], 1);
638	<	close(p1[1]);
639	<	}
640	<	execl("/bin/sh", "sh", "-c", combuf, 0);
641	<	perror("/bin/sh");
642	<	_exit(127);
843	>	strcpy(combuf, prog);
844	>	strcat(combuf, args);
845	>	cp = combuf;
846	>	wp = argv;
847	>	for ( ; ; ) {
848	>	while (isspace(cp)) / nullify spaces */
849	>	*cp++ = '\0';
850	>	if (!cp) / all done? */
851	>	break;
852	>	wp++ = cp; / add argument to list */
853	>	while (++cp && !isspace(cp))
854	>	;
855		}
856	<	if (childpid == -1)
857	<	syserror();
858	<	close(p0[0]);
859	<	close(p1[1]);
860	<	if ((psend = fdopen(p0[1], "w")) == NULL)
861	<	syserror();
862	<	if ((precv = fdopen(p1[0], "r")) == NULL)
863	<	syserror();
856	>	*wp = NULL;
857	>	/* start process */
858	>	if ((rval = open_process(PDesc, argv)) < 0)
859	>	syserror(progname);
860	>	if (rval == 0) {
861	>	fprintf(stderr, "%s: command not found\n", argv[0]);
862	>	exit(1);
863	>	}
864	>	packsiz = rval/(6*sizeof(float)) - 1;
865	>	if (packsiz > PACKSIZ)
866	>	packsiz = PACKSIZ;
867		queuesiz = 0;
868		}
869
870
871	<	caldone() /* done with calculation */
871	>	caldone() /* done with calculation */
872		{
658	–	int pid;
659	–
873		if (childpid == -1)
874		return;
662	–	if (fclose(psend) == EOF)
663	–	syserror();
875		clearqueue();
876	<	fclose(precv);
666	<	while ((pid = wait(0)) != -1 && pid != childpid)
667	<	;
876	>	close_process(PDesc);
877		childpid = -1;
878		}
879
#	Line 672 \| Line 881 \| *caldone() / done with calculation /*
881		rcalfill(x, y) /* fill with ray-calculated pixel */
882		int x, y;
883		{
884	<	FVECT orig, dir;
676	<	float outbuf[6];
677	<
678	<	if (queuesiz >= PACKSIZ) { /* flush queue */
679	<	if (fflush(psend) == EOF)
680	<	syserror();
884	>	if (queuesiz >= packsiz) /* flush queue if needed */
885		clearqueue();
886	<	}
683	<	/* send new ray */
684	<	rayview(orig, dir, &ourview, x+.5, y+.5);
685	<	outbuf[0] = orig[0]; outbuf[1] = orig[1]; outbuf[2] = orig[2];
686	<	outbuf[3] = dir[0]; outbuf[4] = dir[1]; outbuf[5] = dir[2];
687	<	if (fwrite(outbuf, sizeof(float), 6, psend) < 6)
688	<	syserror();
689	<	/* remember it */
886	>	/* add position to queue */
887		queue[queuesiz][0] = x;
888		queue[queuesiz][1] = y;
889		queuesiz++;
890		}
891
892
893	<	clearqueue() /* get results from queue */
893	>	clearqueue() /* process queue */
894		{
895	<	float inbuf[4];
895	>	FVECT orig, dir;
896	>	float fbuf[6*(PACKSIZ+1)];
897	>	register float *fbp;
898		register int i;
899
900	+	if (queuesiz == 0)
901	+	return;
902	+	fbp = fbuf;
903		for (i = 0; i < queuesiz; i++) {
904	<	if (fread(inbuf, sizeof(float), 4, precv) < 4) {
905	<	fprintf(stderr, "%s: read error in clearqueue\n",
906	<	progname);
907	<	exit(1);
904	>	viewray(orig, dir, &ourview,
905	>	(queue[i][0]+.5)/hresolu,
906	>	(queue[i][1]+.5)/vresolu);
907	>	fbp++ = orig[0]; fbp++ = orig[1]; *fbp++ = orig[2];
908	>	fbp++ = dir[0]; fbp++ = dir[1]; *fbp++ = dir[2];
909	>	}
910	>	/* mark end and get results */
911	>	bzero((char )fbp, 6sizeof(float));
912	>	if (process(PDesc, fbuf, fbuf, 4sizeof(float)queuesiz,
913	>	6sizeof(float)(queuesiz+1)) !=
914	>	4sizeof(float)queuesiz) {
915	>	fprintf(stderr, "%s: error reading from rtrace process\n",
916	>	progname);
917	>	exit(1);
918	>	}
919	>	fbp = fbuf;
920	>	for (i = 0; i < queuesiz; i++) {
921	>	if (ourexp > 0 && ourexp != 1.0) {
922	>	fbp[0] *= ourexp;
923	>	fbp[1] *= ourexp;
924	>	fbp[2] *= ourexp;
925		}
926		setcolr(pscan(queue[i][1])[queue[i][0]],
927	<	inbuf[0], inbuf[1], inbuf[2]);
928	<	zscan(queue[i][1])[queue[i][0]] = inbuf[3];
927	>	fbp[0], fbp[1], fbp[2]);
928	>	zscan(queue[i][1])[queue[i][0]] = fbp[3];
929	>	fbp += 4;
930		}
931		queuesiz = 0;
932		}
933
934
935	<	syserror() /* report error and exit */
935	>	syserror(s) /* report error and exit */
936	>	char *s;
937		{
938	<	perror(progname);
938	>	perror(s);
939		exit(1);
940		}

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing ray/src/px/pinterp.c (file contents): Revision 1.14 by greg, Thu Jan 4 17:47:37 1990 UTC vs. Revision 2.16 by greg, Fri Dec 23 15:42:55 1994 UTC

Diff Legend

Comparing ray/src/px/pinterp.c (file contents):
Revision 1.14 by greg, Thu Jan 4 17:47:37 1990 UTC vs.
Revision 2.16 by greg, Fri Dec 23 15:42:55 1994 UTC