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

Comparing ray/src/px/pinterp.c (file contents):
Revision 2.23 by greg, Fri Jan 6 13:19:37 1995 UTC vs.
Revision 2.51 by greg, Mon Nov 20 21:44:29 2023 UTC

#	Line 1 \| Line 1
1	–	/* Copyright (c) 1994 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		* Interpolate and extrapolate pictures with different view parameters.
6		*
7		* Greg Ward 09Dec89
8		*/
9
10	<	#include "standard.h"
10	>	#include "copyright.h"
11
12		#include <ctype.h>
13	+	#include <string.h>
14
15	+	#include "platform.h"
16	+	#include "standard.h"
17	+	#include "rtprocess.h" /* Windows: must come before color.h */
18		#include "view.h"
18	–
19		#include "color.h"
20
21	–	#include "resolu.h"
22	–
21		#define LOG2 0.69314718055994530942
22
23		#define pscan(y) (ourpict+(y)*hresolu)
24		#define sscan(y) (ourspict+(y)*hresolu)
25		#define wscan(y) (ourweigh+(y)*hresolu)
26		#define zscan(y) (ourzbuf+(y)*hresolu)
27	+	#define bscan(y) (ourbpict+(y)*hresolu)
28		#define averaging (ourweigh != NULL)
29	+	#define blurring (ourbpict != NULL)
30		#define usematrix (hasmatrix & !averaging)
31	<	#define zisnorm (!usematrix \| ourview.type != VT_PER)
31	>	#define zisnorm (!usematrix \| (ourview.type != VT_PER))
32
33		#define MAXWT 1000. /* maximum pixel weight (averaging) */
34
#	Line 37 \| Line 37 \| static char SCCSid[] = "$SunId$ LBL";
37
38		#define PACKSIZ 256 /* max. calculation packet size */
39
40	<	#define RTCOM "rtrace -h- -ovl -fff "
40	>	#define RTCOM "rtrace -h- -ovl -fff -ld- -i- -I- "
41
42		#define ABS(x) ((x)>0?(x):-(x))
43
#	Line 59 \| Line 59 \| *COLR ourpict; /* output picture (COLR's) /*
59		COLOR ourspict; / output pixel sums (averaging) */
60		float ourweigh = NULL; / output pixel weights (averaging) */
61		float ourzbuf; / corresponding z-buffer */
62	+	COLOR ourbpict = NULL; / blurred picture (view averaging) */
63
64	+	VIEW avgview; /* average view for -B option */
65	+	int nvavg; /* number of views averaged */
66	+
67		char *progname;
68
69		int fillo = F_FORE\|F_BACK; /* selected fill options */
70		int fillsamp = 0; /* sample separation (0 == inf) */
67	–	extern int backfill(), rcalfill(); /* fill functions */
68	–	int (fillfunc)() = backfill; / selected fill function */
71		COLR backcolr = BLKCOLR; /* background color */
72		COLOR backcolor = BLKCOLOR; /* background color (float) */
73		double backz = 0.0; /* background z value */
74		int normdist = 1; /* i/o normalized distance? */
75	+	char ourfmt[MAXFMTLEN] = PICFMT; /* original picture format */
76		double ourexp = -1; /* original picture exposure */
77		int expadj = 0; /* exposure adjustment (f-stops) */
78		double rexpadj = 1; /* real exposure adjustment */
79
80	<	VIEW theirview = STDVIEW; /* input view */
80	>	VIEW theirview; /* input view */
81		int gotview; /* got input view? */
82		int wrongformat = 0; /* input in another format? */
83		RESOLU tresolu; /* input resolution */
#	Line 82 \| Line 85 \| *double theirexp; / input picture exposure /*
85		MAT4 theirs2ours; /* transformation matrix */
86		int hasmatrix = 0; /* has transformation matrix */
87
88	<	int PDesc[3] = {-1,-1,-1}; /* rtrace process descriptor */
86	<	#define childpid (PDesc[2])
88	>	static SUBPROC PDesc = SP_INACTIVE; /* rtrace process descriptor */
89		unsigned short queue[PACKSIZ][2]; /* pending pixels */
90		int packsiz; /* actual packet size */
91	<	int queuesiz; /* number of pixels pending */
91	>	int queuesiz = 0; /* number of pixels pending */
92
93	<	extern double movepixel();
93	>	typedef void fillfunc_t(int x, int y);
94
95	+	static gethfunc headline;
96	+	static int nextview(FILE *fp);
97	+	static void compavgview(void);
98	+	static void addpicture(char pfile, char zspec);
99	+	static int pixform(MAT4 xfmat, VIEW vw1, VIEW vw2);
100	+	static void addscanline(struct bound *xl, int y,
101	+	COLR pline, float zline, struct position *lasty);
102	+	static void addpixel(struct position p0, struct position p1,
103	+	struct position *p2, COLR pix, double w, double z);
104	+	static double movepixel(FVECT pos);
105	+	static int getperim(struct bound xl, struct bound yl, float *zline, int zfd);
106	+	static void backpicture(fillfunc_t *fill, int samp);
107	+	static void fillpicture(fillfunc_t *fill);
108	+	static int clipaft(void);
109	+	static int addblur(void);
110	+	static void writepicture(void);
111	+	static void writedistance(char *fname);
112	+	static fillfunc_t backfill;
113	+	static fillfunc_t rcalfill;
114	+	static void calstart(char prog, char args);
115	+	static void caldone(void);
116	+	static void clearqueue(void);
117	+	static void syserror(char *s);
118
119	<	main(argc, argv) /* interpolate pictures */
120	<	int argc;
121	<	char *argv[];
119	>	fillfunc_t fillfunc = backfill; / selected fill function */
120	>
121	>	int
122	>	main( /* interpolate pictures */
123	>	int argc,
124	>	char *argv[]
125	>	)
126		{
127	<	#define check(ol,al) if (argv[i][ol] \|\| \
128	<	badarg(argc-i-1,argv+i+1,al)) \
127	>	#define check(ol,al) if (argv[an][ol] \|\| \
128	>	badarg(argc-an-1,argv+an+1,al)) \
129		goto badopt
130		int gotvfile = 0;
131		int doavg = -1;
132	+	int doblur = 0;
133		char *zfile = NULL;
134		char *expcomp = NULL;
135	<	char *err;
106	<	int i, rval;
135	>	int i, an, rval;
136
137	+	SET_DEFAULT_BINARY();
138	+	SET_FILE_BINARY(stdout);
139	+
140		progname = argv[0];
141
142	<	for (i = 1; i < argc && argv[i][0] == '-'; i++) {
143	<	rval = getviewopt(&ourview, argc-i, argv+i);
142	>	for (an = 1; an < argc && argv[an][0] == '-'; an++) {
143	>	rval = getviewopt(&ourview, argc-an, argv+an);
144		if (rval >= 0) {
145	<	i += rval;
145	>	an += rval;
146		continue;
147		}
148	<	switch (argv[i][1]) {
148	>	switch (argv[an][1]) {
149		case 'e': /* exposure */
150		check(2,"f");
151	<	expcomp = argv[++i];
151	>	expcomp = argv[++an];
152		break;
153		case 't': /* threshold */
154		check(2,"f");
155	<	zeps = atof(argv[++i]);
155	>	zeps = atof(argv[++an]);
156		break;
157		case 'a': /* average */
158		check(2,NULL);
159		doavg = 1;
160		break;
161	+	case 'B': /* blur views */
162	+	check(2,NULL);
163	+	doblur = 1;
164	+	break;
165		case 'q': /* quick (no avg.) */
166		check(2,NULL);
167		doavg = 0;
#	Line 135 \| Line 171 \| *char argv[];**
171		normdist = !normdist;
172		break;
173		case 'f': /* fill type */
174	<	switch (argv[i][2]) {
174	>	switch (argv[an][2]) {
175		case '0': /* none */
176		check(3,NULL);
177		fillo = 0;
#	Line 154 \| Line 190 \| *char argv[];**
190		break;
191		case 's': /* sample */
192		check(3,"i");
193	<	fillsamp = atoi(argv[++i]);
193	>	fillsamp = atoi(argv[++an]);
194		break;
195		case 'c': /* color */
196		check(3,"fff");
197		fillfunc = backfill;
198	<	setcolor(backcolor, atof(argv[i+1]),
199	<	atof(argv[i+2]), atof(argv[i+3]));
198	>	setcolor(backcolor, atof(argv[an+1]),
199	>	atof(argv[an+2]), atof(argv[an+3]));
200		setcolr(backcolr, colval(backcolor,RED),
201		colval(backcolor,GRN),
202		colval(backcolor,BLU));
203	<	i += 3;
203	>	an += 3;
204		break;
205		case 'z': /* z value */
206		check(3,"f");
207		fillfunc = backfill;
208	<	backz = atof(argv[++i]);
208	>	backz = atof(argv[++an]);
209		break;
210		case 'r': /* rtrace */
211		check(3,"s");
212		fillfunc = rcalfill;
213	<	calstart(RTCOM, argv[++i]);
213	>	calstart(RTCOM, argv[++an]);
214		break;
215		default:
216		goto badopt;
#	Line 182 \| Line 218 \| *char argv[];**
218		break;
219		case 'z': /* z file */
220		check(2,"s");
221	<	zfile = argv[++i];
221	>	zfile = argv[++an];
222		break;
223		case 'x': /* x resolution */
224		check(2,"i");
225	<	hresolu = atoi(argv[++i]);
225	>	hresolu = atoi(argv[++an]);
226		break;
227		case 'y': /* y resolution */
228		check(2,"i");
229	<	vresolu = atoi(argv[++i]);
229	>	vresolu = atoi(argv[++an]);
230		break;
231		case 'p': /* pixel aspect */
232	<	if (argv[i][2] != 'a')
232	>	if (argv[an][2] != 'a')
233		goto badopt;
234		check(3,"f");
235	<	pixaspect = atof(argv[++i]);
235	>	pixaspect = atof(argv[++an]);
236		break;
237		case 'v': /* view file */
238	<	if (argv[i][2] != 'f')
238	>	if (argv[an][2] != 'f')
239		goto badopt;
240		check(3,"s");
241	<	gotvfile = viewfile(argv[++i], &ourview, 0, 0);
241	>	gotvfile = viewfile(argv[++an], &ourview, NULL);
242		if (gotvfile < 0)
243	<	syserror(argv[i]);
243	>	syserror(argv[an]);
244		else if (gotvfile == 0) {
245		fprintf(stderr, "%s: bad view file\n",
246	<	argv[i]);
246	>	argv[an]);
247		exit(1);
248		}
249		break;
250		default:
251		badopt:
252		fprintf(stderr, "%s: command line error at '%s'\n",
253	<	progname, argv[i]);
253	>	progname, argv[an]);
254		goto userr;
255		}
256		}
257		/* check arguments */
258	<	if ((argc-i)%2)
258	>	if ((argc-an)%2)
259		goto userr;
260		if (fillsamp == 1)
261		fillo &= ~F_BACK;
262		if (doavg < 0)
263	<	doavg = (argc-i) > 2;
264	<	if (expcomp != NULL)
265	<	if (expcomp[0] == '+' \| expcomp[0] == '-') {
263	>	doavg = (argc-an) > 2;
264	>	if (expcomp != NULL) {
265	>	if ((expcomp[0] == '+') \| (expcomp[0] == '-')) {
266		expadj = atof(expcomp) + (expcomp[0]=='+' ? .5 : -.5);
267	<	if (doavg)
267	>	if (doavg \| doblur)
268		rexpadj = pow(2.0, atof(expcomp));
269		else
270		rexpadj = pow(2.0, (double)expadj);
#	Line 237 \| Line 273 \| *char argv[];**
273		goto userr;
274		rexpadj = atof(expcomp);
275		expadj = log(rexpadj)/LOG2 + (rexpadj>1 ? .5 : -.5);
276	<	if (!doavg)
276	>	if (!(doavg \| doblur))
277		rexpadj = pow(2.0, (double)expadj);
278		}
279	+	}
280		/* set view */
281	<	if ((err = setview(&ourview)) != NULL) {
282	<	fprintf(stderr, "%s: %s\n", progname, err);
281	>	if (nextview(doblur ? stdin : (FILE *)NULL) == EOF) {
282	>	fprintf(stderr, "%s: no view on standard input!\n",
283	>	progname);
284		exit(1);
285		}
286		normaspect(viewaspect(&ourview), &pixaspect, &hresolu, &vresolu);
#	Line 250 \| Line 288 \| *char argv[];**
288		if (doavg) {
289		ourspict = (COLOR )bmalloc(hresoluvresolu*sizeof(COLOR));
290		ourweigh = (float )bmalloc(hresoluvresolu*sizeof(float));
291	<	if (ourspict == NULL \| ourweigh == NULL)
291	>	if ((ourspict == NULL) \| (ourweigh == NULL))
292		syserror(progname);
293		} else {
294		ourpict = (COLR )bmalloc(hresoluvresolu*sizeof(COLR));
295		if (ourpict == NULL)
296		syserror(progname);
297		}
298	+	if (doblur) {
299	+	ourbpict = (COLOR )bmalloc(hresoluvresolu*sizeof(COLOR));
300	+	if (ourbpict == NULL)
301	+	syserror(progname);
302	+	}
303		ourzbuf = (float )bmalloc(hresoluvresolu*sizeof(float));
304		if (ourzbuf == NULL)
305		syserror(progname);
263	–	bzero((char )ourzbuf, hresoluvresolu*sizeof(float));
306		/* new header */
307		newheader("RADIANCE", stdout);
308	<	/* get input */
309	<	for ( ; i < argc; i += 2)
310	<	addpicture(argv[i], argv[i+1]);
311	<	/* fill in spaces */
312	<	if (fillo&F_BACK)
313	<	backpicture(fillfunc, fillsamp);
314	<	else
315	<	fillpicture(fillfunc);
308	>	fputnow(stdout);
309	>	/* run pictures */
310	>	do {
311	>	memset((char )ourzbuf, '\0', hresoluvresolu*sizeof(float));
312	>	for (i = an; i < argc; i += 2)
313	>	addpicture(argv[i], argv[i+1]);
314	>	if (fillo&F_BACK) /* fill in spaces */
315	>	backpicture(fillfunc, fillsamp);
316	>	else
317	>	fillpicture(fillfunc);
318	>	/* aft clipping */
319	>	clipaft();
320	>	} while (addblur() && nextview(stdin) != EOF);
321		/* close calculation */
322		caldone();
276	–	/* aft clipping */
277	–	clipaft();
323		/* add to header */
324		printargs(argc, argv, stdout);
325	<	if (gotvfile) {
325	>	compavgview();
326	>	if (doblur \| gotvfile) {
327		fputs(VIEWSTR, stdout);
328	<	fprintview(&ourview, stdout);
328	>	fprintview(&avgview, stdout);
329		putc('\n', stdout);
330		}
331	<	if (pixaspect < .99 \| pixaspect > 1.01)
331	>	if ((pixaspect < .99) \| (pixaspect > 1.01))
332		fputaspect(pixaspect, stdout);
333		if (ourexp > 0)
334		ourexp *= rexpadj;
335		else
336		ourexp = rexpadj;
337	<	if (ourexp < .995 \| ourexp > 1.005)
337	>	if ((ourexp < .995) \| (ourexp > 1.005))
338		fputexpos(ourexp, stdout);
339	<	fputformat(COLRFMT, stdout);
339	>	if (strcmp(ourfmt, PICFMT)) /* print format if known */
340	>	fputformat(ourfmt, stdout);
341		putc('\n', stdout);
342		/* write picture */
343		writepicture();
#	Line 301 \| Line 348 \| *char argv[];**
348		exit(0);
349		userr:
350		fprintf(stderr,
351	<	"Usage: %s [view opts][-t eps][-z zout][-e spec][-a\|-q][-fT][-n] pfile zspec ..\n",
351	>	"Usage: %s [view opts][-t eps][-z zout][-e spec][-B][-a\|-q][-fT][-n] pfile zspec ..\n",
352		progname);
353		exit(1);
354		#undef check
355		}
356
357
358	<	headline(s) /* process header string */
359	<	char *s;
358	>	static int
359	>	headline( /* process header string */
360	>	char *s,
361	>	void *p
362	>	)
363		{
364	<	char fmt[32];
364	>	char fmt[MAXFMTLEN];
365
366		if (isheadid(s))
367	<	return;
367	>	return(0);
368		if (formatval(fmt, s)) {
369	<	wrongformat = strcmp(fmt, COLRFMT);
370	<	return;
369	>	if (globmatch(ourfmt, fmt)) {
370	>	wrongformat = 0;
371	>	strcpy(ourfmt, fmt);
372	>	} else
373	>	wrongformat = 1;
374	>	return(0);
375		}
376	<	putc('\t', stdout);
377	<	fputs(s, stdout);
378	<
376	>	if (nvavg < 2) {
377	>	putc('\t', stdout);
378	>	fputs(s, stdout);
379	>	}
380		if (isexpos(s)) {
381		theirexp *= exposval(s);
382	<	return;
382	>	return(0);
383		}
384		if (isview(s) && sscanview(&theirview, s) > 0)
385		gotview++;
386	+	return(0);
387		}
388
389
390	<	addpicture(pfile, zspec) /* add picture to output */
391	<	char pfile, zspec;
390	>	static int
391	>	nextview( /* get and set next view */
392	>	FILE *fp
393	>	)
394		{
395	+	char linebuf[256];
396	+	char *err;
397	+	int i;
398	+
399	+	if (fp != NULL) {
400	+	do /* get new view */
401	+	if (fgets(linebuf, sizeof(linebuf), fp) == NULL)
402	+	return(EOF);
403	+	while (!isview(linebuf) \|\| !sscanview(&ourview, linebuf));
404	+	}
405	+	/* set new view */
406	+	if ((err = setview(&ourview)) != NULL) {
407	+	fprintf(stderr, "%s: %s\n", progname, err);
408	+	exit(1);
409	+	}
410	+	if (!nvavg) { /* first view */
411	+	avgview = ourview;
412	+	return(nvavg++);
413	+	}
414	+	/* add to average view */
415	+	for (i = 0; i < 3; i++) {
416	+	avgview.vp[i] += ourview.vp[i];
417	+	avgview.vdir[i] += ourview.vdir[i];
418	+	avgview.vup[i] += ourview.vup[i];
419	+	}
420	+	avgview.vdist += ourview.vdist;
421	+	avgview.horiz += ourview.horiz;
422	+	avgview.vert += ourview.vert;
423	+	avgview.hoff += ourview.hoff;
424	+	avgview.voff += ourview.voff;
425	+	avgview.vfore += ourview.vfore;
426	+	avgview.vaft += ourview.vaft;
427	+	return(nvavg++);
428	+	}
429	+
430	+
431	+	static void
432	+	compavgview(void) /* compute average view */
433	+	{
434	+	int i;
435	+	double f;
436	+
437	+	if (nvavg < 2)
438	+	return;
439	+	f = 1.0/nvavg;
440	+	for (i = 0; i < 3; i++) {
441	+	avgview.vp[i] *= f;
442	+	avgview.vdir[i] *= f;
443	+	avgview.vup[i] *= f;
444	+	}
445	+	avgview.vdist *= f;
446	+	avgview.horiz *= f;
447	+	avgview.vert *= f;
448	+	avgview.hoff *= f;
449	+	avgview.voff *= f;
450	+	avgview.vfore *= f;
451	+	avgview.vaft *= f;
452	+	if (setview(&avgview) != NULL) /* in case of emergency... */
453	+	avgview = ourview;
454	+	pixaspect = viewaspect(&avgview) * hresolu / vresolu;
455	+	}
456	+
457	+
458	+	static void
459	+	addpicture( /* add picture to output */
460	+	char *pfile,
461	+	char *zspec
462	+	)
463	+	{
464		FILE *pfp;
465		int zfd;
466		char *err;
#	Line 347 \| Line 474 \| *char pfile, zspec;*
474		syserror(pfile);
475		/* get header with exposure and view */
476		theirexp = 1.0;
477	+	theirview = stdview;
478		gotview = 0;
479	<	printf("%s:\n", pfile);
479	>	if (nvavg < 2)
480	>	printf("%s:\n", pfile);
481		getheader(pfp, headline, NULL);
482		if (wrongformat \|\| !gotview \|\| !fgetsresolu(&tresolu, pfp)) {
483		fprintf(stderr, "%s: picture format error\n", pfile);
#	Line 358 \| Line 487 \| *char pfile, zspec;*
487		ourexp = theirexp;
488		else if (ABS(theirexp-ourexp) > .01*ourexp)
489		fprintf(stderr, "%s: different exposure (warning)\n", pfile);
490	<	if (err = setview(&theirview)) {
490	>	if ( (err = setview(&theirview)) ) {
491		fprintf(stderr, "%s: %s\n", pfile, err);
492		exit(1);
493		}
#	Line 368 \| Line 497 \| *char pfile, zspec;*
497		zin = (float )malloc(scanlen(&tresolu)sizeof(float));
498		if (zin == NULL)
499		syserror(progname);
500	<	if ((zfd = open(zspec, O_RDONLY)) == -1) {
501	<	double zvalue;
502	<	register int x;
503	<	if (!isflt(zspec) \|\| (zvalue = atof(zspec)) <= 0.0)
504	<	syserror(zspec);
500	>	if (isflt(zspec)) { /* depth is a constant? */
501	>	double zvalue = atof(zspec);
502	>	int x;
503	>	if (zvalue <= 0.0) {
504	>	fprintf(stderr, "%s: illegal Z-value %s\n",
505	>	progname, zspec);
506	>	exit(1);
507	>	}
508		for (x = scanlen(&tresolu); x-- > 0; )
509		zin[x] = zvalue;
510	<	}
510	>	zfd = -1;
511	>	} else if ((zfd = open_float_depth(zspec, (long)tresolu.xr*tresolu.yr)) < 0)
512	>	exit(1);
513		/* compute transferrable perimeter */
514		xlim = (struct bound )malloc(numscans(&tresolu)sizeof(struct bound));
515		if (xlim == NULL)
516		syserror(progname);
517		if (!getperim(xlim, &ylim, zin, zfd)) { /* overlapping area? */
518	<	free((char *)zin);
519	<	free((char *)xlim);
518	>	free((void *)zin);
519	>	free((void *)xlim);
520		if (zfd != -1)
521		close(zfd);
522		fclose(pfp);
#	Line 392 \| Line 526 \| *char pfile, zspec;*
526		scanin = (COLR )malloc(scanlen(&tresolu)sizeof(COLR));
527		plast = (struct position *)calloc(scanlen(&tresolu),
528		sizeof(struct position));
529	<	if (scanin == NULL \| plast == NULL)
529	>	if ((scanin == NULL) \| (plast == NULL))
530		syserror(progname);
531		/* skip to starting point */
532		for (y = 0; y < ylim.min; y++)
#	Line 401 \| Line 535 \| *char pfile, zspec;*
535		exit(1);
536		}
537		if (zfd != -1 && lseek(zfd,
538	<	(long)ylim.minscanlen(&tresolu)sizeof(float), 0) < 0)
538	>	(off_t)ylim.minscanlen(&tresolu)sizeof(float),
539	>	SEEK_SET) < 0)
540		syserror(zspec);
541		/* load image */
542		for (y = ylim.min; y <= ylim.max; y++) {
#	Line 416 \| Line 551 \| *char pfile, zspec;*
551		addscanline(xlim+y, y, scanin, zin, plast);
552		}
553		/* clean up */
554	<	free((char *)xlim);
555	<	free((char *)scanin);
556	<	free((char *)zin);
557	<	free((char *)plast);
554	>	free((void *)xlim);
555	>	free((void *)scanin);
556	>	free((void *)zin);
557	>	free((void *)plast);
558		fclose(pfp);
559		if (zfd != -1)
560		close(zfd);
561		}
562
563
564	<	pixform(xfmat, vw1, vw2) /* compute view1 to view2 matrix */
565	<	register MAT4 xfmat;
566	<	register VIEW vw1, vw2;
564	>	static int
565	>	pixform( /* compute view1 to view2 matrix */
566	>	MAT4 xfmat,
567	>	VIEW *vw1,
568	>	VIEW *vw2
569	>	)
570		{
571	<	double m4t[4][4];
571	>	MAT4 m4t;
572
573	<	if (vw1->type != VT_PER && vw1->type != VT_PAR)
573	>	if ((vw1->type != VT_PER) & (vw1->type != VT_PAR))
574		return(0);
575	<	if (vw2->type != VT_PER && vw2->type != VT_PAR)
575	>	if ((vw2->type != VT_PER) & (vw2->type != VT_PAR))
576		return(0);
577		setident4(xfmat);
578		xfmat[0][0] = vw1->hvec[0];
#	Line 467 \| Line 605 \| *register VIEW vw1, vw2;*
605		}
606
607
608	<	addscanline(xl, y, pline, zline, lasty) /* add scanline to output */
609	<	struct bound *xl;
610	<	int y;
611	<	COLR *pline;
612	<	float *zline;
613	<	struct position lasty; / input/output */
608	>	static void
609	>	addscanline( /* add scanline to output */
610	>	struct bound *xl,
611	>	int y,
612	>	COLR *pline,
613	>	float *zline,
614	>	struct position lasty / input/output */
615	>	)
616		{
617		FVECT pos;
618		struct position lastx, newpos;
619		double wt;
620	<	register int x;
620	>	int x;
621
622		lastx.z = 0;
623		for (x = xl->max; x >= xl->min; x--) {
#	Line 499 \| Line 639 \| *struct position lasty; /* input/output /*
639		}
640
641
642	<	addpixel(p0, p1, p2, pix, w, z) /* fill in pixel parallelogram */
643	<	struct position p0, p1, *p2;
644	<	COLR pix;
645	<	double w;
646	<	double z;
642	>	static void
643	>	addpixel( /* fill in pixel parallelogram */
644	>	struct position *p0,
645	>	struct position *p1,
646	>	struct position *p2,
647	>	COLR pix,
648	>	double w,
649	>	double z
650	>	)
651		{
652		double zt = 2.zepsp0->z; /* threshold */
653		COLOR pval; /* converted+weighted pixel */
#	Line 511 \| Line 655 \| double z;
655		int l1, l2, c1, c2; /* side lengths and counters */
656		int p1isy; /* p0p1 along y? */
657		int x1, y1; /* p1 position */
658	<	register int x, y; /* final position */
658	>	int x, y; /* final position */
659
660		/* compute vector p0p1 */
661		if (fillo&F_FORE && ABS(p1->z-p0->z) <= zt) {
662		s1x = p1->x - p0->x;
663		s1y = p1->y - p0->y;
664		l1 = ABS(s1x);
665	<	if (p1isy = (ABS(s1y) > l1))
665	>	if ( (p1isy = (ABS(s1y) > l1)) )
666		l1 = ABS(s1y);
667		else if (l1 < 1)
668		l1 = 1;
#	Line 551 \| Line 695 \| double z;
695		y1 = p0->y + c1*s1y/l1;
696		for (c2 = l2; c2-- > 0; ) {
697		x = x1 + c2*s2x/l2;
698	<	if (x < 0 \|\| x >= hresolu)
698	>	if ((x < 0) \| (x >= hresolu))
699		continue;
700		y = y1 + c2*s2y/l2;
701	<	if (y < 0 \|\| y >= vresolu)
701	>	if ((y < 0) \| (y >= vresolu))
702		continue;
703		if (averaging) {
704		if (zscan(y)[x] <= 0 \|\| zscan(y)[x]-z
#	Line 576 \| Line 720 \| double z;
720		}
721
722
723	<	double
724	<	movepixel(pos) /* reposition image point */
725	<	register FVECT pos;
723	>	static double
724	>	movepixel( /* reposition image point */
725	>	FVECT pos
726	>	)
727		{
728		FVECT pt, tdir, odir;
729		double d;
585	–	register int i;
730
731		if (pos[2] <= 0) /* empty pixel */
732		return(0);
733		if (usematrix) {
734		pos[0] += theirview.hoff - .5;
735		pos[1] += theirview.voff - .5;
736	<	if (normdist && theirview.type == VT_PER)
736	>	if (normdist & (theirview.type == VT_PER))
737		d = sqrt(1. + pos[0]pos[0]theirview.hn2
738		+ pos[1]pos[1]theirview.vn2);
739		else
#	Line 609 \| Line 753 \| register FVECT pos;
753		}
754		pos[0] += .5 - ourview.hoff;
755		pos[1] += .5 - ourview.voff;
756	+	if ((pos[0] < 0) \| (pos[0] >= 1-FTINY) \|
757	+	(pos[1] < 0) \| (pos[1] >= 1-FTINY))
758	+	return(0);
759		pos[2] -= ourview.vfore;
760		} else {
761		if (viewray(pt, tdir, &theirview, pos[0], pos[1]) < -FTINY)
762		return(0);
763	<	if (!normdist & theirview.type == VT_PER) /* adjust */
764	<	pos[2] = sqrt(1. + pos[0]pos[0]*theirview.hn2
618	<	+ pos[1]pos[1]theirview.vn2);
763	>	if (!normdist & (theirview.type == VT_PER)) /* adjust */
764	>	pos[2] /= DOT(theirview.vdir, tdir);
765		pt[0] += tdir[0]*pos[2];
766		pt[1] += tdir[1]*pos[2];
767		pt[2] += tdir[2]*pos[2];
768	<	viewloc(pos, &ourview, pt);
623	<	if (pos[2] <= 0)
768	>	if (viewloc(pos, &ourview, pt) != VL_GOOD)
769		return(0);
770		}
626	–	if (pos[0] < 0 \|\| pos[0] >= 1-FTINY \|\| pos[1] < 0 \|\| pos[1] >= 1-FTINY)
627	–	return(0);
771		if (!averaging)
772		return(1);
773	<	if (ourview.type == VT_PAR) /* compute our direction */
774	<	VCOPY(odir, ourview.vdir);
775	<	else
776	<	for (i = 0; i < 3; i++)
777	<	odir[i] = (pt[i] - ourview.vp[i])/pos[2];
778	<	d = DOT(odir,tdir); /* compute pixel weight */
779	<	if (d >= 1.-1./MAXWT/MAXWT)
773	>	/* compute pixel weight */
774	>	if (ourview.type == VT_PAR) {
775	>	d = DOT(ourview.vdir,tdir);
776	>	d = 1. - d*d;
777	>	} else {
778	>	VSUB(odir, pt, ourview.vp);
779	>	d = DOT(odir,tdir);
780	>	d = 1. - d*d/DOT(odir,odir);
781	>	}
782	>	if (d <= 1./MAXWT/MAXWT)
783		return(MAXWT); /* clip to maximum weight */
784	<	return(1./sqrt(1.-d));
784	>	return(1./sqrt(d));
785		}
786
787
788	<	getperim(xl, yl, zline, zfd) /* compute overlapping image area */
789	<	register struct bound *xl;
790	<	struct bound *yl;
791	<	float *zline;
792	<	int zfd;
788	>	static int
789	>	getperim( /* compute overlapping image area */
790	>	struct bound *xl,
791	>	struct bound *yl,
792	>	float *zline,
793	>	int zfd
794	>	)
795		{
796		int step;
797		FVECT pos;
798	<	register int x, y;
798	>	int x, y;
799		/* set up step size */
800		if (scanlen(&tresolu) < numscans(&tresolu))
801		step = scanlen(&tresolu)/NSTEPS;
#	Line 666 \| Line 814 \| int zfd;
814		yl->min = 32000; yl->max = 0; /* search for points on image */
815		for (y = step - 1; y < numscans(&tresolu); y += step) {
816		if (zfd != -1) {
817	<	if (lseek(zfd, (long)yscanlen(&tresolu)sizeof(float),
818	<	0) < 0)
817	>	if (lseek(zfd, (off_t)yscanlen(&tresolu)sizeof(float),
818	>	SEEK_SET) < 0)
819		syserror("lseek");
820		if (read(zfd, (char *)zline,
821		scanlen(&tresolu)*sizeof(float))
#	Line 712 \| Line 860 \| int zfd;
860		xl[y-1].max = xl[y-step].max;
861		}
862		for (x = 2; x < step; x++)
863	<	copystruct(xl+y-x, xl+y-1);
863	>	(xl+y-x) = (xl+y-1);
864		}
865		if (yl->max >= numscans(&tresolu))
866		yl->max = numscans(&tresolu) - 1;
867		y -= step;
868		for (x = numscans(&tresolu) - 1; x > y; x--) /* fill bottom rows */
869	<	copystruct(xl+x, xl+y);
869	>	(xl+x) = (xl+y);
870		return(yl->max >= yl->min);
871		}
872
873
874	<	backpicture(fill, samp) /* background fill algorithm */
875	<	int (*fill)();
876	<	int samp;
874	>	static void
875	>	backpicture( /* background fill algorithm */
876	>	fillfunc_t *fill,
877	>	int samp
878	>	)
879		{
880		int *yback, xback;
881		int y;
882	<	register int x, i;
882	>	int x, i;
883		/* get back buffer */
884		yback = (int )malloc(hresolusizeof(int));
885		if (yback == NULL)
#	Line 827 \| Line 977 \| int samp;
977		xback = -2;
978		}
979		}
980	<	free((char *)yback);
980	>	free((void *)yback);
981		}
982
983
984	<	fillpicture(fill) /* paint in empty pixels using fill */
985	<	int (*fill)();
984	>	static void
985	>	fillpicture( /* paint in empty pixels using fill */
986	>	fillfunc_t *fill
987	>	)
988		{
989	<	register int x, y;
989	>	int x, y;
990
991		for (y = 0; y < vresolu; y++)
992		for (x = 0; x < hresolu; x++)
993		if (zscan(y)[x] <= 0)
994		(*fill)(x,y);
995	+	if (fill == rcalfill)
996	+	clearqueue();
997		}
998
999
1000	<	clipaft() /* perform aft clipping as indicated */
1000	>	static int
1001	>	clipaft(void) /* perform aft clipping as indicated */
1002		{
1003	<	register int x, y;
1004	<	int adjtest = ourview.type == VT_PER & zisnorm;
1003	>	int x, y;
1004	>	int adjtest = (ourview.type == VT_PER) & zisnorm;
1005		double tstdist;
1006		double yzn2, vx;
1007
1008		if (ourview.vaft <= FTINY)
1009	<	return;
1009	>	return(0);
1010		tstdist = ourview.vaft - ourview.vfore;
1011		for (y = 0; y < vresolu; y++) {
1012		if (adjtest) { /* adjust test */
#	Line 869 \| Line 1024 \| *clipaft() / perform aft clipping as indicated /*
1024		continue;
1025		}
1026		if (averaging)
1027	<	bzero(sscan(y)[x], sizeof(COLOR));
1027	>	memset(sscan(y)[x], '\0', sizeof(COLOR));
1028		else
1029	<	bzero(pscan(y)[x], sizeof(COLR));
1029	>	memset(pscan(y)[x], '\0', sizeof(COLR));
1030		zscan(y)[x] = 0.0;
1031		}
1032		}
1033	+	return(1);
1034		}
1035
1036
1037	<	writepicture() /* write out picture (alters buffer) */
1037	>	static int
1038	>	addblur(void) /* add to blurred picture */
1039		{
1040	+	COLOR cval;
1041	+	double d;
1042	+	int i;
1043	+
1044	+	if (!blurring)
1045	+	return(0);
1046	+	i = hresolu*vresolu;
1047	+	if (nvavg < 2)
1048	+	if (averaging)
1049	+	while (i--) {
1050	+	copycolor(ourbpict[i], ourspict[i]);
1051	+	d = 1.0/ourweigh[i];
1052	+	scalecolor(ourbpict[i], d);
1053	+	}
1054	+	else
1055	+	while (i--)
1056	+	colr_color(ourbpict[i], ourpict[i]);
1057	+	else
1058	+	if (averaging)
1059	+	while (i--) {
1060	+	copycolor(cval, ourspict[i]);
1061	+	d = 1.0/ourweigh[i];
1062	+	scalecolor(cval, d);
1063	+	addcolor(ourbpict[i], cval);
1064	+	}
1065	+	else
1066	+	while (i--) {
1067	+	colr_color(cval, ourpict[i]);
1068	+	addcolor(ourbpict[i], cval);
1069	+	}
1070	+	/* print view */
1071	+	printf("VIEW%d:", nvavg);
1072	+	fprintview(&ourview, stdout);
1073	+	putchar('\n');
1074	+	return(1);
1075	+	}
1076	+
1077	+
1078	+	static void
1079	+	writepicture(void) /* write out picture (alters buffer) */
1080	+	{
1081		int y;
1082	<	register int x;
1082	>	int x;
1083		double d;
1084
1085		fprtresolu(hresolu, vresolu, stdout);
1086		for (y = vresolu-1; y >= 0; y--)
1087	<	if (averaging) {
1087	>	if (blurring) {
1088	>	for (x = 0; x < hresolu; x++) { /* compute avg. */
1089	>	d = rexpadj/nvavg;
1090	>	scalecolor(bscan(y)[x], d);
1091	>	}
1092	>	if (fwritescan(bscan(y), hresolu, stdout) < 0)
1093	>	syserror(progname);
1094	>	} else if (averaging) {
1095		for (x = 0; x < hresolu; x++) { /* average pixels */
1096		d = rexpadj/wscan(y)[x];
1097		scalecolor(sscan(y)[x], d);
#	Line 902 \| Line 1107 \| *writepicture() / write out picture (alters buffer)**
1107		}
1108
1109
1110	<	writedistance(fname) /* write out z file (alters buffer) */
1111	<	char *fname;
1110	>	static void
1111	>	writedistance( /* write out z file (alters buffer) */
1112	>	char *fname
1113	>	)
1114		{
1115		int donorm = normdist & !zisnorm ? 1 :
1116	<	ourview.type == VT_PER & !normdist & zisnorm ? -1 : 0;
1116	>	(ourview.type == VT_PER) & !normdist & zisnorm ? -1 : 0;
1117		int fd;
1118		int y;
1119
#	Line 915 \| Line 1122 \| *char fname;**
1122		for (y = vresolu-1; y >= 0; y--) {
1123		if (donorm) {
1124		double vx, yzn2, d;
1125	<	register int x;
1125	>	int x;
1126		yzn2 = (y+.5)/vresolu + ourview.voff - .5;
1127		yzn2 = 1. + yzn2yzn2ourview.vn2;
1128		for (x = 0; x < hresolu; x++) {
#	Line 935 \| Line 1142 \| *char fname;**
1142		}
1143
1144
1145	<	backfill(x, y) /* fill pixel with background */
1146	<	int x, y;
1145	>	static void
1146	>	backfill( /* fill pixel with background */
1147	>	int x,
1148	>	int y
1149	>	)
1150		{
1151		if (averaging) {
1152		copycolor(sscan(y)[x], backcolor);
#	Line 947 \| Line 1157 \| int x, y;
1157		}
1158
1159
1160	<	calstart(prog, args) /* start fill calculation */
1161	<	char prog, args;
1160	>	static void
1161	>	calstart( /* start fill calculation */
1162	>	char *prog,
1163	>	char *args
1164	>	)
1165		{
1166		char combuf[512];
1167		char *argv[64];
1168		int rval;
1169	<	register char *wp, cp;
1169	>	char *wp, cp;
1170
1171	<	if (childpid != -1) {
1171	>	if (PDesc.flags & PF_RUNNING) {
1172		fprintf(stderr, "%s: too many calculations\n", progname);
1173		exit(1);
1174		}
#	Line 974 \| Line 1187 \| *char prog, args;*
1187		}
1188		*wp = NULL;
1189		/* start process */
1190	<	if ((rval = open_process(PDesc, argv)) < 0)
1190	>	if ((rval = open_process(&PDesc, argv)) < 0)
1191		syserror(progname);
1192		if (rval == 0) {
1193		fprintf(stderr, "%s: command not found\n", argv[0]);
#	Line 987 \| Line 1200 \| *char prog, args;*
1200		}
1201
1202
1203	<	caldone() /* done with calculation */
1203	>	static void
1204	>	caldone(void) /* done with calculation */
1205		{
1206	<	if (childpid == -1)
1206	>	if (!(PDesc.flags & PF_RUNNING))
1207		return;
1208		clearqueue();
1209	<	close_process(PDesc);
996	<	childpid = -1;
1209	>	close_process(&PDesc);
1210		}
1211
1212
1213	<	rcalfill(x, y) /* fill with ray-calculated pixel */
1214	<	int x, y;
1213	>	static void
1214	>	rcalfill( /* fill with ray-calculated pixel */
1215	>	int x,
1216	>	int y
1217	>	)
1218		{
1219		if (queuesiz >= packsiz) /* flush queue if needed */
1220		clearqueue();
#	Line 1009 \| Line 1225 \| int x, y;
1225		}
1226
1227
1228	<	clearqueue() /* process queue */
1228	>	static void
1229	>	clearqueue(void) /* process queue */
1230		{
1231		FVECT orig, dir;
1232		float fbuf[6*(PACKSIZ+1)];
1233	<	register float *fbp;
1234	<	register int i;
1233	>	float *fbp;
1234	>	int i;
1235		double vx, vy;
1236
1237		if (queuesiz == 0)
#	Line 1028 \| Line 1245 \| *clearqueue() / process queue /*
1245		fbp++ = dir[0]; fbp++ = dir[1]; *fbp++ = dir[2];
1246		}
1247		/* mark end and get results */
1248	<	bzero((char )fbp, 6sizeof(float));
1249	<	if (process(PDesc, fbuf, fbuf, 4sizeof(float)queuesiz,
1248	>	memset((char )fbp, '\0', 6sizeof(float));
1249	>	if (process(&PDesc, (char )fbuf, (char )fbuf,
1250	>	4sizeof(float)(queuesiz+1),
1251		6sizeof(float)(queuesiz+1)) !=
1252	<	4sizeof(float)queuesiz) {
1252	>	4sizeof(float)(queuesiz+1)) {
1253		fprintf(stderr, "%s: error reading from rtrace process\n",
1254		progname);
1255		exit(1);
#	Line 1064 \| Line 1282 \| *clearqueue() / process queue /*
1282		}
1283
1284
1285	<	syserror(s) /* report error and exit */
1286	<	char *s;
1285	>	static void
1286	>	syserror( /* report error and exit */
1287	>	char *s
1288	>	)
1289		{
1290		perror(s);
1291		exit(1);

Diff Legend

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

Comparing ray/src/px/pinterp.c (file contents): Revision 2.23 by greg, Fri Jan 6 13:19:37 1995 UTC vs. Revision 2.51 by greg, Mon Nov 20 21:44:29 2023 UTC

Diff Legend

Comparing ray/src/px/pinterp.c (file contents):
Revision 2.23 by greg, Fri Jan 6 13:19:37 1995 UTC vs.
Revision 2.51 by greg, Mon Nov 20 21:44:29 2023 UTC