--- ray/src/px/pinterp.c	1990/01/03 09:37:16	1.8
+++ ray/src/px/pinterp.c	1990/01/04 16:52:05	1.13
@@ -17,6 +17,13 @@ static char SCCSid[] = "$SunId$ LBL";
 #define pscan(y)	(ourpict+(y)*ourview.hresolu)
 #define zscan(y)	(ourzbuf+(y)*ourview.hresolu)
 
+#define F_FORE		1		/* fill foreground */
+#define F_BACK		2		/* fill background */
+
+#define PACKSIZ		42		/* calculation packet size */
+
+#define RTCOM		"rtrace -h -ovl -fff -x %d %s"
+
 #define ABS(x)		((x)>0?(x):-(x))
 
 VIEW	ourview = STDVIEW(512);		/* desired view */
@@ -31,15 +38,29 @@ char	*progname;
 VIEW	theirview = STDVIEW(512);	/* input view */
 int	gotview;			/* got input view? */
 
+int	fill = F_FORE|F_BACK;		/* selected fill algorithm */
+extern int	backfill(), calfill();	/* fill functions */
+int	(*deffill)() = backfill;	/* selected fill function */
+COLR	backcolr = BLKCOLR;		/* background color */
+double	backz = 0.0;			/* background z value */
+
 double	theirs2ours[4][4];		/* transformation matrix */
+int	normdist = 1;			/* normalized distance? */
 
+FILE	*psend, *precv;			/* pipes to/from fill calculation */
+int	childpid;			/* child's process id */
+int	queue[PACKSIZ][2];		/* pending pixels */
+int	queuesiz;			/* number of pixels pending */
 
+
 main(argc, argv)			/* interpolate pictures */
 int	argc;
 char	*argv[];
 {
 #define check(olen,narg)	if (argv[i][olen] || narg >= argc-i) goto badopt
+	extern double	atof();
 	int	gotvfile = 0;
+	char	*zfile = NULL;
 	char	*err;
 	int	i;
 
@@ -51,6 +72,53 @@ char	*argv[];
 			check(2,1);
 			zeps = atof(argv[++i]);
 			break;
+		case 'n':				/* dist. normalized? */
+			check(2,0);
+			normdist = !normdist;
+			break;
+		case 'f':				/* fill type */
+			switch (argv[i][2]) {
+			case '0':				/* none */
+				check(3,0);
+				fill = 0;
+				break;
+			case 'f':				/* foreground */
+				check(3,0);
+				fill = F_FORE;
+				break;
+			case 'b':				/* background */
+				check(3,0);
+				fill = F_BACK;
+				break;
+			case 'a':				/* all */
+				check(3,0);
+				fill = F_FORE|F_BACK;
+				break;
+			case 'c':				/* color */
+				check(3,3);
+				deffill = backfill;
+				setcolr(backcolr, atof(argv[i+1]),
+					atof(argv[i+2]), atof(argv[i+3]));
+				i += 3;
+				break;
+			case 'z':				/* z value */
+				check(3,1);
+				deffill = backfill;
+				backz = atof(argv[++i]);
+				break;
+			case 'r':				/* rtrace */
+				check(3,1);
+				deffill = calfill;
+				calstart(RTCOM, argv[++i]);
+				break;
+			default:
+				goto badopt;
+			}
+			break;
+		case 'z':				/* z file */
+			check(2,1);
+			zfile = argv[++i];
+			break;
 		case 'x':				/* x resolution */
 			check(2,1);
 			ourview.hresolu = atoi(argv[++i]);
@@ -109,23 +177,20 @@ char	*argv[];
 			break;
 		default:
 		badopt:
-			fprintf(stderr, "%s: unknown option '%s'\n",
+			fprintf(stderr, "%s: command line error at '%s'\n",
 					progname, argv[i]);
-			exit(1);
+			goto userr;
 		}
 						/* check arguments */
-	if (argc-i < 2 || (argc-i)%2) {
-		fprintf(stderr, "Usage: %s [view args] pfile zfile ..\n",
-				progname);
-		exit(1);
-	}
+	if ((argc-i)%2)
+		goto userr;
 						/* set view */
 	if (err = setview(&ourview)) {
 		fprintf(stderr, "%s: %s\n", progname, err);
 		exit(1);
 	}
 						/* allocate frame */
-	ourpict = (COLR *)calloc(ourview.hresolu*ourview.vresolu,sizeof(COLR));
+	ourpict = (COLR *)malloc(ourview.hresolu*ourview.vresolu*sizeof(COLR));
 	ourzbuf = (float *)calloc(ourview.hresolu*ourview.vresolu,sizeof(float));
 	if (ourpict == NULL || ourzbuf == NULL) {
 		perror(progname);
@@ -135,7 +200,13 @@ char	*argv[];
 	for ( ; i < argc; i += 2)
 		addpicture(argv[i], argv[i+1]);
 							/* fill in spaces */
-	fillpicture();
+	if (fill&F_BACK)
+		backpicture();
+	else
+		fillpicture();
+							/* close calculation */
+	if (deffill == calfill)
+		caldone();
 							/* add to header */
 	printargs(argc, argv, stdout);
 	if (gotvfile) {
@@ -144,10 +215,18 @@ char	*argv[];
 		printf("\n");
 	}
 	printf("\n");
-							/* write output */
+							/* write picture */
 	writepicture();
+							/* write z file */
+	if (zfile != NULL)
+		writedistance(zfile);
 
 	exit(0);
+userr:
+	fprintf(stderr,
+	"Usage: %s [view opts][-t zthresh][-z zout][-fT][-n] pfile zspec ..\n",
+			progname);
+	exit(1);
 #undef check
 }
 
@@ -169,35 +248,30 @@ char	*s;
 }
 
 
-addpicture(pfile, zfile)		/* add picture to output */
-char	*pfile, *zfile;
+addpicture(pfile, zspec)		/* add picture to output */
+char	*pfile, *zspec;
 {
+	extern double	atof();
 	FILE	*pfp, *zfp;
 	char	*err;
 	COLR	*scanin;
-	float	*zin, *zout;
-	int	*pout;
-	int	xres, yres;
+	float	*zin, *zlast;
+	int	*plast;
 	int	y;
-					/* open input files */
+					/* open picture file */
 	if ((pfp = fopen(pfile, "r")) == NULL) {
 		perror(pfile);
 		exit(1);
 	}
-	if ((zfp = fopen(zfile, "r")) == NULL) {
-		perror(zfile);
-		exit(1);
-	}
 					/* get header and view */
 	printf("%s:\n", pfile);
 	gotview = 0;
 	getheader(pfp, headline);
-	if (!gotview || fgetresolu(&xres, &yres, pfp) != (YMAJOR|YDECR)) {
+	if (!gotview || fgetresolu(&theirview.hresolu, &theirview.vresolu, pfp)
+			!= (YMAJOR|YDECR)) {
 		fprintf(stderr, "%s: picture view error\n", pfile);
 		exit(1);
 	}
-	theirview.hresolu = xres;
-	theirview.vresolu = yres;
 	if (err = setview(&theirview)) {
 		fprintf(stderr, "%s: %s\n", pfile, err);
 		exit(1);
@@ -205,33 +279,47 @@ char	*pfile, *zfile;
 					/* compute transformation */
 	pixform(theirs2ours, &theirview, &ourview);
 					/* allocate scanlines */
-	scanin = (COLR *)malloc(xres*sizeof(COLR));
-	zin = (float *)malloc(xres*sizeof(float));
-	zout = (float *)calloc(xres, sizeof(float));
-	pout = (int *)calloc(xres, sizeof(int));
-	if (scanin == NULL || zin == NULL || zout == NULL || pout == NULL) {
+	scanin = (COLR *)malloc(theirview.hresolu*sizeof(COLR));
+	zin = (float *)malloc(theirview.hresolu*sizeof(float));
+	plast = (int *)calloc(theirview.hresolu, sizeof(int));
+	zlast = (float *)calloc(theirview.hresolu, sizeof(float));
+	if (scanin == NULL || zin == NULL || plast == NULL || zlast == NULL) {
 		perror(progname);
 		exit(1);
 	}
+					/* get z specification or file */
+	if ((zfp = fopen(zspec, "r")) == NULL) {
+		double	zvalue;
+		register int	x;
+		if (!isfloat(zspec) || (zvalue = atof(zspec)) <= 0.0) {
+			perror(zspec);
+			exit(1);
+		}
+		for (x = 0; x < theirview.hresolu; x++)
+			zin[x] = zvalue;
+	}
 					/* load image */
-	for (y = yres-1; y >= 0; y--) {
-		if (freadcolrs(scanin, xres, pfp) < 0) {
+	for (y = theirview.vresolu-1; y >= 0; y--) {
+		if (freadcolrs(scanin, theirview.hresolu, pfp) < 0) {
 			fprintf(stderr, "%s: read error\n", pfile);
 			exit(1);
 		}
-		if (fread(zin, sizeof(float), xres, zfp) < xres) {
-			fprintf(stderr, "%s: read error\n", zfile);
+		if (zfp != NULL
+			&& fread(zin,sizeof(float),theirview.hresolu,zfp)
+				< theirview.hresolu) {
+			fprintf(stderr, "%s: read error\n", zspec);
 			exit(1);
 		}
-		addscanline(y, scanin, zin, pout, zout);
+		addscanline(y, scanin, zin, plast, zlast);
 	}
 					/* clean up */
 	free((char *)scanin);
 	free((char *)zin);
-	free((char *)pout);
-	free((char *)zout);
+	free((char *)plast);
+	free((char *)zlast);
 	fclose(pfp);
-	fclose(zfp);
+	if (zfp != NULL)
+		fclose(zfp);
 }
 
 
@@ -275,10 +363,10 @@ addscanline(y, pline, zline, lasty, lastyz)	/* add sca
 int	y;
 COLR	*pline;
 float	*zline;
-int	*lasty;
-float	*lastyz;
+int	*lasty;			/* input/output */
+float	*lastyz;		/* input/output */
 {
-	extern double	sqrt(), fabs();
+	extern double	sqrt();
 	double	pos[3];
 	int	lastx = 0;
 	double	lastxz = 0;
@@ -291,12 +379,8 @@ float	*lastyz;
 		pos[1] = y - .5*(theirview.vresolu-1);
 		pos[2] = zline[x];
 		if (theirview.type == VT_PER) {
-			/*
-			 * The following (single) statement can go
-			 * if z is along the view direction rather
-			 * than an eye ray.
-			 */
-			pos[2] /= sqrt( 1.
+			if (normdist)	/* adjust for eye-ray distance */
+				pos[2] /= sqrt( 1.
 					+ pos[0]*pos[0]*theirview.vhn2
 					+ pos[1]*pos[1]*theirview.vvn2 );
 			pos[0] *= pos[2];
@@ -317,8 +401,10 @@ float	*lastyz;
 					/* add pixel to our image */
 		zt = 2.*zeps*zline[x];
 		addpixel(xpos, ypos,
-			(fabs(zline[x]-lastxz) <= zt) ? lastx - xpos : 1,
-			(fabs(zline[x]-lastyz[x]) <= zt) ? lasty[x] - ypos : 1,
+			(fill&F_FORE && ABS(zline[x]-lastxz) <= zt)
+				? lastx - xpos : 1,
+			(fill&F_FORE && ABS(zline[x]-lastyz[x]) <= zt)
+				? lasty[x] - ypos : 1,
 			pline[x], pos[2]);
 		lastx = xpos;
 		lasty[x] = ypos;
@@ -356,7 +442,7 @@ double	z;
 }
 
 
-fillpicture()				/* fill in empty spaces */
+backpicture()				/* background fill algorithm */
 {
 	int	*yback, xback;
 	int	y;
@@ -399,7 +485,7 @@ fillpicture()				/* fill in empty spaces */
 				 * Next, find background from left or right.
 				 */
 				if (xback == -2) {
-					for (i = x+1; x < ourview.hresolu; i++)
+					for (i = x+1; i < ourview.hresolu; i++)
 						if (zscan(y)[i] > 0)
 							break;
 					if (i < ourview.hresolu
@@ -408,18 +494,29 @@ fillpicture()				/* fill in empty spaces */
 					else
 						xback = x-1;
 				}
-				if (xback < 0 && yback[x] < 0)
-					continue;	/* no background */
 				/*
+				 * Check to see if we have no background for
+				 * this pixel.  If not, use background color.
+				 */
+				if (xback < 0 && yback[x] < 0) {
+					(*deffill)(x,y);
+					continue;
+				}
+				/*
 				 * Compare, and use the background that is
 				 * farther, unless one of them is next to us.
 				 */
-				if (yback[x] < 0 || ABS(x-xback) <= 1
+				if ( yback[x] < 0
+					|| (xback >= 0 && ABS(x-xback) <= 1)
 					|| ( ABS(y-yback[x]) > 1
-				&& zscan(yback[x])[x] < zscan(y)[xback] ))
+						&& zscan(yback[x])[x]
+						< zscan(y)[xback] ) ) {
 					copycolr(pscan(y)[x],pscan(y)[xback]);
-				else
+					zscan(y)[x] = zscan(y)[xback];
+				} else {
 					copycolr(pscan(y)[x],pscan(yback[x])[x]);
+					zscan(y)[x] = zscan(yback[x])[x];
+				}
 			} else {				/* full pixel */
 				yback[x] = -2;
 				xback = -2;
@@ -429,6 +526,17 @@ fillpicture()				/* fill in empty spaces */
 }
 
 
+fillpicture()				/* paint in empty pixels with default */
+{
+	register int	x, y;
+
+	for (y = 0; y < ourview.vresolu; y++)
+		for (x = 0; x < ourview.hresolu; x++)
+			if (zscan(y)[x] <= 0)
+				(*deffill)(x,y);
+}
+
+
 writepicture()				/* write out picture */
 {
 	int	y;
@@ -439,4 +547,157 @@ writepicture()				/* write out picture */
 			perror(progname);
 			exit(1);
 		}
+}
+
+
+writedistance(fname)			/* write out z file */
+char	*fname;
+{
+	extern double	sqrt();
+	int	donorm = normdist && ourview.type == VT_PER;
+	FILE	*fp;
+	int	y;
+	float	*zout;
+
+	if ((fp = fopen(fname, "w")) == NULL) {
+		perror(fname);
+		exit(1);
+	}
+	if (donorm
+	&& (zout = (float *)malloc(ourview.hresolu*sizeof(float))) == NULL) {
+		perror(progname);
+		exit(1);
+	}
+	for (y = ourview.vresolu-1; y >= 0; y--) {
+		if (donorm) {
+			double	vx, yzn2;
+			register int	x;
+			yzn2 = y - .5*(ourview.vresolu-1);
+			yzn2 = 1. + yzn2*yzn2*ourview.vvn2;
+			for (x = 0; x < ourview.hresolu; x++) {
+				vx = x - .5*(ourview.hresolu-1);
+				zout[x] = zscan(y)[x]
+					* sqrt(vx*vx*ourview.vhn2 + yzn2);
+			}
+		} else
+			zout = zscan(y);
+		if (fwrite(zout, sizeof(float), ourview.hresolu, fp)
+				< ourview.hresolu) {
+			perror(fname);
+			exit(1);
+		}
+	}
+	if (donorm)
+		free((char *)zout);
+	fclose(fp);
+}
+
+
+isfloat(s)				/* see if string is floating number */
+register char	*s;
+{
+	for ( ; *s; s++)
+		if ((*s < '0' || *s > '9') && *s != '.' && *s != '-'
+				&& *s != 'e' && *s != 'E' && *s != '+')
+			return(0);
+	return(1);
+}
+
+
+backfill(x, y)				/* fill pixel with background */
+int	x, y;
+{
+	register BYTE	*dest = pscan(y)[x];
+
+	copycolr(dest, backcolr);
+	zscan(y)[x] = backz;
+}
+
+
+calstart(prog, args)			/* start fill calculation */
+char	*prog, *args;
+{
+	char	combuf[512];
+	int	p0[2], p1[2];
+
+	sprintf(combuf, prog, PACKSIZ, args);
+	if (pipe(p0) < 0 || pipe(p1) < 0)
+		goto syserr;
+	if ((childpid = vfork()) == 0) {	/* fork calculation */
+		close(p0[1]);
+		close(p1[0]);
+		if (p0[0] != 0) {
+			dup2(p0[0], 0);
+			close(p0[0]);
+		}
+		if (p1[1] != 1) {
+			dup2(p1[1], 1);
+			close(p1[1]);
+		}
+		execl("/bin/sh", "sh", "-c", combuf, 0);
+		perror("/bin/sh");
+		_exit(127);
+	}
+	if (childpid < 0)
+		goto syserr;
+	close(p0[0]);
+	close(p1[1]);
+	if ((psend = fdopen(p0[1], "w")) == NULL)
+		goto syserr;
+	if ((precv = fdopen(p1[0], "r")) == NULL)
+		goto syserr;
+	queuesiz = 0;
+	return;
+syserr:
+	perror(progname);
+	exit(1);
+}
+
+
+caldone()				/* done with calculation */
+{
+	int	pid;
+
+	fclose(psend);
+	clearqueue();
+	fclose(precv);
+	while ((pid = wait(0)) != -1 && pid != childpid)
+		;
+}
+
+
+calfill(x, y)				/* fill with calculated pixel */
+int	x, y;
+{
+	FVECT	orig, dir;
+	float	outbuf[6];
+
+	if (queuesiz >= PACKSIZ) {	/* flush queue */
+		fflush(psend);
+		clearqueue();
+	}
+					/* send new ray */
+	rayview(orig, dir, &ourview, x+.5, y+.5);
+	outbuf[0] = orig[0]; outbuf[1] = orig[1]; outbuf[2] = orig[2];
+	outbuf[3] = dir[0]; outbuf[4] = dir[1]; outbuf[5] = dir[2];
+	fwrite(outbuf, sizeof(float), 6, psend);
+					/* remember it */
+	queue[queuesiz][0] = x;
+	queue[queuesiz][1] = y;
+	queuesiz++;
+}
+
+
+clearqueue()				/* get results from queue */
+{
+	float	inbuf[4];
+	register int	i;
+
+	for (i = 0; i < queuesiz; i++) {
+		fread(inbuf, sizeof(float), 4, precv);
+		setcolr(pscan(queue[i][1])[queue[i][0]],
+				inbuf[0], inbuf[1], inbuf[2]);
+		zscan(queue[i][1])[queue[i][0]] = inbuf[3];
+	}
+	queuesiz = 0;
 }