--- ray/src/util/rtcontrib.c	2006/06/07 17:52:04	1.43
+++ ray/src/util/rtcontrib.c	2007/11/17 16:27:14	1.48
@@ -1,5 +1,5 @@
 #ifndef lint
-static const char RCSid[] = "$Id: rtcontrib.c,v 1.43 2006/06/07 17:52:04 schorsch Exp $";
+static const char RCSid[] = "$Id: rtcontrib.c,v 1.48 2007/11/17 16:27:14 greg Exp $";
 #endif
 /*
  * Gather rtrace output to compute contributions from particular sources
@@ -27,7 +27,7 @@ typedef double	DCOLOR[3];		/* double-precision color *
 /*
  * The MODCONT structure is used to accumulate ray contributions
  * for a particular modifier, which may be subdivided into bins
- * if binv is non-zero.  If outspec contains a %s in it, this will
+ * if binv evaluates > 0.  If outspec contains a %s in it, this will
  * be replaced with the modifier name.  If outspec contains a %d in it,
  * this will be used to create one output file per bin, otherwise all bins
  * will be written to the same file, in order.  If the global outfmt
@@ -46,16 +46,15 @@ static void mcfree(void *p) { epfree((*(MODCONT *)p).b
 
 LUTAB	modconttab = LU_SINIT(NULL,mcfree);	/* modifier lookup table */
 
-#define	CNT_UNKNOWN	0		/* unknown record length */
-#define CNT_PIPE	(-1)		/* output to a pipe */
 /*
  * The STREAMOUT structure holds an open FILE pointer and a count of
- * the number of RGB triplets per record, or CNT_UNKNOWN (0) if
- * unknown or CNT_PIPE (-1) if writing to a command.
+ * the number of RGB triplets per record, or 0 if unknown.
  */
 typedef struct {
 	FILE		*ofp;		/* output file pointer */
+	int		outpipe;	/* output is to a pipe */
 	int		reclen;		/* triplets/record */
+	int		xr, yr;		/* output resolution for picture */
 } STREAMOUT;
 
 /* close output stream and free record */
@@ -64,7 +63,7 @@ closestream(void *p)
 {
 	STREAMOUT	*sop = (STREAMOUT *)p;
 	int		status;
-	if (sop->reclen == CNT_PIPE)
+	if (sop->outpipe)
 		status = pclose(sop->ofp);
 	else
 		status = fclose(sop->ofp);
@@ -81,7 +80,7 @@ LUTAB	ofiletab = LU_SINIT(free,closestream);	/* output
 STREAMOUT *getostream(const char *ospec, const char *mname, int bn, int noopen);
 int ofname(char *oname, const char *ospec, const char *mname, int bn);
 void printheader(FILE *fout, const char *info);
-void printresolu(FILE *fout);
+void printresolu(FILE *fout, int xr, int yr);
 
 /*
  * The rcont structure is used to manage i/o with a particular
@@ -115,7 +114,12 @@ struct rtproc	rt0;			/* head of rtrace process list */
 
 struct rtproc	*rt_unproc = NULL;	/* unprocessed ray trees */
 
-char	persistfn[] = "pfXXXXXX";	/* persist file name */
+#define PERSIST_NONE	0		/* no persist file */
+#define PERSIST_SINGLE	1		/* user set -P persist */
+#define PERSIST_PARALL	2		/* user set -PP persist */
+#define PERSIST_OURS	3		/* -PP persist belongs to us */
+int	persist_state = PERSIST_NONE;	/* persist file state */
+char	persistfn[] = "pfXXXXXX";	/* our persist file name, if set */
 
 int		gargc;			/* global argc */
 char		**gargv;		/* global argv */
@@ -127,7 +131,9 @@ int		inpfmt = 'a';		/* input format */
 int		outfmt = 'a';		/* output format */
 
 int		header = 1;		/* output header? */
+int		accumulate = 0;		/* accumulate ray values? */
 int		force_open = 0;		/* truncate existing output? */
+int		recover = 0;		/* recover previous output? */
 int		xres = 0;		/* horiz. output resolution */
 int		yres = 0;		/* vert. output resolution */
 
@@ -150,6 +156,7 @@ void addmodfile(char *fname, char *outf, char *binv, i
 
 void init(int np);
 int done_rprocs(struct rtproc *rtp);
+void reload_output(void);
 void recover_output(FILE *fin);
 void trace_contribs(FILE *fin);
 struct rtproc *wait_rproc(void);
@@ -214,7 +221,6 @@ main(int argc, char *argv[])
 {
 	int	contrib = 0;
 	int	nprocs = 1;
-	int	recover = 0;
 	char	*curout = NULL;
 	char	*binval = NULL;
 	int	bincnt = 0;
@@ -268,9 +274,26 @@ main(int argc, char *argv[])
 					continue;
 				}
 				break;
+			case 'c':		/* accumulate ray values */
+				switch (argv[i][2]) {
+				case '\0':
+					accumulate = !accumulate;
+					continue;
+				case '+': case '1':
+				case 'T': case 't':
+				case 'Y': case 'y':
+					accumulate = 1;
+					continue;
+				case '-': case '0':
+				case 'F': case 'f':
+				case 'N': case 'n':
+					accumulate = 0;
+					continue;
+				}
+				break;
 			case 'r':		/* recover output */
 				if (argv[i][2]) break;
-				recover++;
+				recover = 1;
 				continue;
 			case 'h':		/* output header? */
 				switch (argv[i][2]) {
@@ -305,7 +328,7 @@ main(int argc, char *argv[])
 					continue;
 				}
 				if (argv[i][2] == 'o') {
-					force_open++;
+					force_open = 1;
 					continue;
 				}
 				setformat(argv[i]+2);
@@ -348,11 +371,17 @@ main(int argc, char *argv[])
 				addmodfile(argv[i], curout, binval, bincnt);
 				continue;
 			case 'P':		/* persist file */
-				error(USER, "persist file is automatic");
-				break;
+				if (i >= argc-2) break;
+				persist_state = (argv[i][2] == 'P') ?
+						PERSIST_PARALL : PERSIST_SINGLE;
+				rtargv[rtargc++] = argv[i];
+				rtargv[rtargc++] = argv[++i];
+				continue;
 			}
 		rtargv[rtargc++] = argv[i];	/* assume rtrace option */
 	}
+	if (accumulate)		/* no output flushing for single record */
+		xres = yres = 0;
 				/* set global argument list */
 	gargc = argc; gargv = argv;
 				/* add "mandatory" rtrace settings */
@@ -366,6 +395,9 @@ main(int argc, char *argv[])
 		printf("-n  %-2d\t\t\t\t# number of processes\n", nprocs);
 		printf("-V%c\t\t\t\t# output %s\n", contrib ? '+' : '-',
 				contrib ? "contributions" : "coefficients");
+		printf("-c%c\t\t\t\t# %s\n", accumulate ? '+' : '-',
+				accumulate ? "accumulate ray values" :
+					"one output record per ray");
 		fflush(stdout);			/* report OUR options */
 		rtargv[rtargc++] = header ? "-h+" : "-h-";
 		sprintf(fmt, "-f%c%c", inpfmt, outfmt);
@@ -389,8 +421,13 @@ main(int argc, char *argv[])
 		exit(1);
 	}
 	if (nprocs > 1) {	/* add persist file if parallel */
-		rtargv[rtargc++] = "-PP";
-		rtargv[rtargc++] = mktemp(persistfn);
+		if (persist_state == PERSIST_SINGLE)
+			error(USER, "use -PP option for multiple processes");
+		if (persist_state == PERSIST_NONE) {
+			rtargv[rtargc++] = "-PP";
+			rtargv[rtargc++] = mktemp(persistfn);
+			persist_state = PERSIST_OURS;
+		}
 	} 
 				/* add format string */
 	sprintf(fmt, "-f%cf", inpfmt);
@@ -400,11 +437,11 @@ main(int argc, char *argv[])
 		error(USER, "missing octree argument");
 	rtargv[rtargc++] = octree = argv[i];
 	rtargv[rtargc] = NULL;
-				/* start rtrace */
+				/* start rtrace & recover if requested */
 	init(nprocs);
-	if (recover)		/* perform recovery if requested */
-		recover_output(stdin);
-	trace_contribs(stdin);	/* compute contributions */
+				/* compute contributions */
+	trace_contribs(stdin);
+				/* clean up */
 	quit(0);
 }
 
@@ -450,7 +487,7 @@ quit(int status)
 {
 	int	rtstat;
 
-	if (rt0.next != NULL)		/* terminate persistent rtrace */
+	if (persist_state == PERSIST_OURS)  /* terminate waiting rtrace */
 		killpersist();
 					/* clean up rtrace process(es) */
 	rtstat = done_rprocs(&rt0);
@@ -518,6 +555,13 @@ init(int np)
 	} else
 		raysleft = 0;
 	waitflush = xres;
+	if (!recover)
+		return;
+					/* recover previous values */
+	if (accumulate)
+		reload_output();
+	else
+		recover_output(stdin);
 }
 
 /* grow modifier to accommodate more bins */
@@ -567,7 +611,7 @@ addmodifier(char *modn, char *outf, char *binv, int bi
 		mp = growmodifier(mp, bincnt);
 	lep->data = (char *)mp;
 					/* allocate output streams */
-	for (i = outf==NULL || outf[0]=='!' ? 0 : bincnt; i-- > 0; )
+	for (i = bincnt; i-- > 0; )
 		getostream(mp->outspec, mp->modname, i, 1);
 	return mp;
 }
@@ -688,19 +732,19 @@ printheader(FILE *fout, const char *info)
 
 /* write resolution string to given output stream */
 void
-printresolu(FILE *fout)
+printresolu(FILE *fout, int xr, int yr)
 {
-	if (xres > 0) {
-		if (yres > 0)			/* resolution string */
-			fprtresolu(xres, yres, fout);
+	if ((xr > 0) & (yr > 0))	/* resolution string */
+		fprtresolu(xr, yr, fout);
+	if (xres > 0)			/* global flush flag */
 		fflush(fout);
-	}
 }
 
 /* Get output stream pointer (open and write header if new and noopen==0) */
 STREAMOUT *
 getostream(const char *ospec, const char *mname, int bn, int noopen)
 {
+	static const DCOLOR	nocontrib = BLKCOLOR;
 	static STREAMOUT	stdos;
 	int			ofl;
 	char			oname[1024];
@@ -709,12 +753,12 @@ getostream(const char *ospec, const char *mname, int b
 	
 	if (ospec == NULL) {			/* use stdout? */
 		if (!noopen && !using_stdout) {
-			stdos.reclen = 0;
 			if (outfmt != 'a')
 				SET_FILE_BINARY(stdout);
 			if (header)
 				printheader(stdout, NULL);
-			printresolu(stdout);
+			printresolu(stdout, xres, yres);
+			stdos.xr = xres; stdos.yr = yres;
 			using_stdout = 1;
 		}
 		stdos.ofp = stdout;
@@ -734,22 +778,25 @@ getostream(const char *ospec, const char *mname, int b
 		sop = (STREAMOUT *)malloc(sizeof(STREAMOUT));
 		if (sop == NULL)
 			error(SYSTEM, "out of memory in getostream");
-		sop->reclen = oname[0] == '!' ? CNT_PIPE : CNT_UNKNOWN;
+		sop->outpipe = oname[0] == '!';
+		sop->reclen = 0;
 		sop->ofp = NULL;		/* open iff noopen==0 */
+		sop->xr = xres; sop->yr = yres;
 		lep->data = (char *)sop;
+		if (!sop->outpipe & !force_open & !recover &&
+				access(oname, F_OK) == 0) {
+			errno = EEXIST;		/* file exists */
+			goto openerr;
+		}
 	}
 	if (!noopen && sop->ofp == NULL) {	/* open output stream */
 		long		i;
 		if (oname[0] == '!')		/* output to command */
 			sop->ofp = popen(oname+1, "w");
-		else if (!force_open && access(oname, F_OK) == 0)
-			errno = EEXIST;		/* file exists */
-		else				/* else open it */
+		else				/* else open file */
 			sop->ofp = fopen(oname, "w");
-		if (sop->ofp == NULL) {
-			sprintf(errmsg, "cannot open '%s' for writing", oname);
-			error(SYSTEM, errmsg);
-		}
+		if (sop->ofp == NULL)
+			goto openerr;
 		if (outfmt != 'a')
 			SET_FILE_BINARY(sop->ofp);
 		if (header) {
@@ -766,29 +813,36 @@ getostream(const char *ospec, const char *mname, int b
 			*cp = '\0';
 			printheader(sop->ofp, info);
 		}
-		printresolu(sop->ofp);
+		if (!accumulate) {		/* global res. for -c- */
+			sop->xr = xres; sop->yr = yres;
+		}
+		printresolu(sop->ofp, sop->xr, sop->yr);
 						/* play catch-up */
-		for (i = sop->reclen > 1 ? sop->reclen*lastdone : lastdone;
-								i--; ) {
-			static const DCOLOR	nocontrib = BLKCOLOR;
-			put_contrib(nocontrib, sop->ofp);
+		for (i = accumulate ? 0 : lastdone; i--; ) {
+			int	j = sop->reclen;
+			if (j <= 0) j = 1;
+			while (j--)
+				put_contrib(nocontrib, sop->ofp);
 			if (outfmt == 'a')
 				putc('\n', sop->ofp);
 		}
 		if (xres > 0)
 			fflush(sop->ofp);
 	}
-	if (sop->reclen != CNT_PIPE)		/* add to length if noopen */
-		sop->reclen += noopen;
-	return sop;				/* return open stream */
+	sop->reclen += noopen;			/* add to length if noopen */
+	return sop;				/* return output stream */
+openerr:
+	sprintf(errmsg, "cannot open '%s' for writing", oname);
+	error(SYSTEM, errmsg);
+	return NULL;	/* pro forma return */
 }
 
 /* read input ray into buffer */
 int
 getinp(char *buf, FILE *fp)
 {
-	double	dv[3];
-	float	fv[3];
+	double	dv[3], *dvp;
+	float	*fvp;
 	char	*cp;
 	int	i;
 
@@ -812,15 +866,15 @@ getinp(char *buf, FILE *fp)
 	case 'f':
 		if (fread(buf, sizeof(float), 6, fp) < 6)
 			return -1;
-		memcpy(fv, buf+3*sizeof(float), 3*sizeof(float));
-		if (DOT(fv,fv) <= FTINY*FTINY)
+		fvp = (float *)buf + 3;
+		if (DOT(fvp,fvp) <= FTINY*FTINY)
 			return 0;	/* dummy ray */
 		return sizeof(float)*6;
 	case 'd':
 		if (fread(buf, sizeof(double), 6, fp) < 6)
 			return -1;
-		memcpy(dv, buf+3*sizeof(double), 3*sizeof(double));
-		if (DOT(dv,dv) <= FTINY*FTINY)
+		dvp = (double *)buf + 3;
+		if (DOT(dvp,dvp) <= FTINY*FTINY)
 			return 0;	/* dummy ray */
 		return sizeof(double)*6;
 	}
@@ -889,9 +943,7 @@ put_contrib(const DCOLOR cnt, FILE *fout)
 		fprintf(fout, "%.6e\t%.6e\t%.6e\t", cnt[0], cnt[1], cnt[2]);
 		break;
 	case 'f':
-		fv[0] = cnt[0];
-		fv[1] = cnt[1];
-		fv[2] = cnt[2];
+		copycolor(fv, cnt);
 		fwrite(fv, sizeof(float), 3, fout);
 		break;
 	case 'd':
@@ -906,7 +958,7 @@ put_contrib(const DCOLOR cnt, FILE *fout)
 	}
 }
 
-/* output ray tallies and clear for next primary */
+/* output ray tallies and clear for next accumulation */
 void
 done_contrib(void)
 {
@@ -926,7 +978,7 @@ done_contrib(void)
 			for (j = 1; j < mp->nbins; j++)
 				put_contrib(mp->cbin[j],
 				    getostream(mp->outspec,mp->modname,j,0)->ofp);
-						/* clear for next ray tree */
+						/* clear for next time */
 		memset(mp->cbin, 0, sizeof(DCOLOR)*mp->nbins);
 	}
 	--waitflush;				/* terminate records */
@@ -999,7 +1051,8 @@ process_queue(void)
 			cp += sizeof(float)*9; n -= sizeof(float)*9;
 			add_contrib(modname);
 		}
-		done_contrib();		/* sum up contributions & output */
+		if (!accumulate)
+			done_contrib();	/* sum up contributions & output */
 		lastdone = rtp->raynum;
 		if (rtp->buf != NULL)	/* free up buffer space */
 			free(rtp->buf);
@@ -1114,11 +1167,159 @@ trace_contribs(FILE *fin)
 	}
 	while (wait_rproc() != NULL)		/* process outstanding rays */
 		process_queue();
+	if (accumulate)
+		done_contrib();			/* output tallies */
 	if (raysleft)
 		error(USER, "unexpected EOF on input");
 	lu_done(&ofiletab);			/* close output files */
 }
 
+/* get ray contribution from previous file */
+static int
+get_contrib(DCOLOR cnt, FILE *finp)
+{
+	COLOR	fv;
+	COLR	cv;
+
+	switch (outfmt) {
+	case 'a':
+		return(fscanf(finp,"%lf %lf %lf",&cnt[0],&cnt[1],&cnt[2]) == 3);
+	case 'f':
+		if (fread(fv, sizeof(fv[0]), 3, finp) != 3)
+			return(0);
+		copycolor(cnt, fv);
+		return(1);
+	case 'd':
+		return(fread(cnt, sizeof(cnt[0]), 3, finp) == 3);
+	case 'c':
+		if (fread(cv, sizeof(cv), 1, finp) != 1)
+			return(0);
+		colr_color(fv, cv);
+		copycolor(cnt, fv);
+		return(1);
+	default:
+		error(INTERNAL, "botched output format");
+	}
+	return(0);	/* pro forma return */
+}
+
+/* close output file opened for input */
+static int
+myclose(const LUENT *e, void *p)
+{
+	STREAMOUT	*sop = (STREAMOUT *)e->data;
+	
+	if (sop->ofp == NULL)
+		return;
+	fclose(sop->ofp);
+	sop->ofp = NULL;
+}
+
+/* load previously accumulated values */
+void
+reload_output(void)
+{
+	int		i, j;
+	MODCONT		*mp;
+	int		ofl;
+	char		oname[1024];
+	char		*fmode = "rb";
+	char		*outvfmt;
+	LUENT		*ment, *oent;
+	int		xr, yr;
+	STREAMOUT	sout;
+	DCOLOR		rgbv;
+
+	switch (outfmt) {
+	case 'a':
+		outvfmt = "ascii";
+		fmode = "r";
+		break;
+	case 'f':
+		outvfmt = "float";
+		break;
+	case 'd':
+		outvfmt = "double";
+		break;
+	case 'c':
+		outvfmt = COLRFMT;
+		break;
+	default:
+		error(INTERNAL, "botched output format");
+		return;
+	}
+						/* reload modifier values */
+	for (i = 0; i < nmods; i++) {
+		ment = lu_find(&modconttab,modname[i]);
+		mp = (MODCONT *)ment->data;
+		if (mp->outspec == NULL)
+			error(USER, "cannot reload from stdout");
+		if (mp->outspec[0] == '!')
+			error(USER, "cannot reload from command");
+		for (j = 0; ; j++) {		/* load each modifier bin */
+			ofl = ofname(oname, mp->outspec, mp->modname, j);
+			if (ofl < 0)
+				error(USER, "bad output file specification");
+			oent = lu_find(&ofiletab, oname);
+			if (oent->data != NULL) {
+				sout = *(STREAMOUT *)oent->data;
+			} else {
+				sout.reclen = 0;
+				sout.outpipe = 0;
+				sout.xr = xres; sout.yr = yres;
+				sout.ofp = NULL;
+			}
+			if (sout.ofp == NULL) {	/* open output as input */
+				sout.ofp = fopen(oname, fmode);
+				if (sout.ofp == NULL) {
+					if (j)
+						break;	/* assume end of modifier */
+					sprintf(errmsg, "missing reload file '%s'",
+							oname);
+					error(WARNING, errmsg);
+					break;
+				}
+				if (header && checkheader(sout.ofp, outvfmt, NULL) != 1) {
+					sprintf(errmsg, "format mismatch for '%s'",
+							oname);
+					error(USER, errmsg);
+				}
+				if ((sout.xr > 0) & (sout.yr > 0) &&
+						(!fscnresolu(&xr, &yr, sout.ofp) ||
+							(xr != sout.xr) |
+							(yr != sout.yr))) {
+					sprintf(errmsg, "resolution mismatch for '%s'",
+							oname);
+					error(USER, errmsg);
+				}
+			}
+							/* read in RGB value */
+			if (!get_contrib(rgbv, sout.ofp)) {
+				if (!j) {
+					fclose(sout.ofp);
+					break;		/* ignore empty file */
+				}
+				if (j < mp->nbins) {
+					sprintf(errmsg, "missing data in '%s'",
+							oname);
+					error(USER, errmsg);
+				}
+				break;
+			}
+			if (j >= mp->nbins)		/* grow modifier size */
+				ment->data = (char *)(mp = growmodifier(mp, j+1));
+			copycolor(mp->cbin[j], rgbv);
+			if (oent->key == NULL)		/* new file entry */
+				oent->key = strcpy((char *)
+						malloc(strlen(oname)+1), oname);
+			if (oent->data == NULL)
+				oent->data = (char *)malloc(sizeof(STREAMOUT));
+			*(STREAMOUT *)oent->data = sout;
+		}
+	}
+	lu_doall(&ofiletab, myclose, NULL);	/* close all files */
+}
+
 /* seek on the given output file */
 static int
 myseeko(const LUENT *e, void *p)
@@ -1187,7 +1388,8 @@ recover_output(FILE *fin)
 			if (oent->data != NULL) {
 				sout = *(STREAMOUT *)oent->data;
 			} else {
-				sout.reclen = CNT_UNKNOWN;
+				sout.reclen = 0;
+				sout.outpipe = 0;
 				sout.ofp = NULL;
 			}
 			if (sout.ofp != NULL) {	/* already open? */
@@ -1202,7 +1404,8 @@ recover_output(FILE *fin)
 					break;	/* assume end of modifier */
 				sprintf(errmsg, "missing recover file '%s'",
 						oname);
-				error(USER, errmsg);
+				error(WARNING, errmsg);
+				break;
 			}
 			nvals = lseek(fileno(sout.ofp), 0, SEEK_END);
 			if (nvals <= 0) {
@@ -1210,7 +1413,7 @@ recover_output(FILE *fin)
 				fclose(sout.ofp);
 				break;
 			}
-			if (sout.reclen == CNT_UNKNOWN) {
+			if (!sout.reclen) {
 				if (!(ofl & OF_BIN)) {
 					sprintf(errmsg,
 						"need -bn to recover file '%s'",
@@ -1227,10 +1430,11 @@ recover_output(FILE *fin)
 						oname);
 				error(USER, errmsg);
 			}
-			if ((xres > 0) & (yres > 0) &&
+			sout.xr = xres; sout.yr = yres;
+			if ((sout.xr > 0) & (sout.yr > 0) &&
 					(!fscnresolu(&xr, &yr, sout.ofp) ||
-						xr != xres ||
-						yr != yres)) {
+						(xr != sout.xr) |
+						(yr != sout.yr))) {
 				sprintf(errmsg, "resolution mismatch for '%s'",
 						oname);
 				error(USER, errmsg);