ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/util/rtcontrib.c

Comparing ray/src/util/rtcontrib.c (file contents):
Revision 1.48 by greg, Sat Nov 17 16:27:14 2007 UTC vs.
Revision 1.55 by greg, Wed Dec 9 21:43:35 2009 UTC

#	Line 99 | Line 99 | struct rtproc {
99
100		/* rtrace command and defaults */
101		char            *rtargv[256+2*MAXMODLIST] = { "rtrace",
102	<	"-dj", ".5", "-dr", "3",
102	>	"-dj", ".9", "-dr", "3",
103		"-ab", "1", "-ad", "350", };
104
105		int  rtargc = 9;
#	Line 131 | Line 131 | int            inpfmt = 'a';           /* input format */
131		int             outfmt = 'a';           /* output format */
132
133		int             header = 1;             /* output header? */
134	–	int             accumulate = 0;         /* accumulate ray values? */
134		int             force_open = 0;         /* truncate existing output? */
135		int             recover = 0;            /* recover previous output? */
136	+	int             accumulate = 1;         /* input rays per output record */
137		int             xres = 0;               /* horiz. output resolution */
138		int             yres = 0;               /* vert. output resolution */
139
140	+	int             account;                /* current accumulation count */
141		unsigned long   raysleft;               /* number of rays left to trace */
142		long            waitflush;              /* how long until next flush */
143
#	Line 166 | Line 167 | void process_queue(void);
167
168		void put_contrib(const DCOLOR cnt, FILE *fout);
169		void add_contrib(const char *modn);
170	<	void done_contrib(void);
170	>	void done_contrib(int navg);
171
172		/* return number of open rtrace processes */
173		static int
#	Line 245 | Line 246 | main(int argc, char *argv[])
246		while ((j = expandarg(&argc, &argv, i)) > 0)
247		;
248		if (j < 0) {
249	<	fprintf(stderr, "%s: cannot expand '%s'",
249	>	fprintf(stderr, "%s: cannot expand '%s'\n",
250		argv[0], argv[i]);
251		exit(1);
252		}
#	Line 274 | Line 275 | main(int argc, char *argv[])
275		continue;
276		}
277		break;
278	<	case 'c':               /* accumulate ray values */
279	<	switch (argv[i][2]) {
280	<	case '\0':
281	<	accumulate = !accumulate;
281	<	continue;
282	<	case '+': case '1':
283	<	case 'T': case 't':
284	<	case 'Y': case 'y':
285	<	accumulate = 1;
286	<	continue;
287	<	case '-': case '0':
288	<	case 'F': case 'f':
289	<	case 'N': case 'n':
290	<	accumulate = 0;
291	<	continue;
292	<	}
293	<	break;
278	>	case 'c':               /* input rays per output */
279	>	if (argv[i][2] || i >= argc-2) break;
280	>	accumulate = atoi(argv[++i]);
281	>	continue;
282		case 'r':               /* recover output */
283		if (argv[i][2]) break;
284		recover = 1;
#	Line 352 | Line 340 | main(int argc, char *argv[])
340		case 'b':               /* bin expression/count */
341		if (i >= argc-2) break;
342		if (argv[i][2] == 'n') {
343	<	bincnt = atoi(argv[++i]);
343	>	bincnt = (int)(eval(argv[++i]) + .5);
344		continue;
345		}
346		if (argv[i][2]) break;
#	Line 380 | Line 368 | main(int argc, char *argv[])
368		}
369		rtargv[rtargc++] = argv[i];     /* assume rtrace option */
370		}
371	<	if (accumulate)         /* no output flushing for single record */
371	>	if (accumulate <= 0)    /* no output flushing for single record */
372		xres = yres = 0;
373		/* set global argument list */
374		gargc = argc; gargv = argv;
#	Line 392 | Line 380 | main(int argc, char *argv[])
380		if (!strcmp(argv[i], "-defaults")) {
381		char    sxres[16], syres[16];
382		char    *rtpath;
383	<	printf("-n  %-2d\t\t\t\t# number of processes\n", nprocs);
383	>	printf("-n %-2d\t\t\t\t# number of processes\n", nprocs);
384	>	printf("-c %-5d\t\t\t# accumulated rays per record\n",
385	>	accumulate);
386		printf("-V%c\t\t\t\t# output %s\n", contrib ? '+' : '-',
387		contrib ? "contributions" : "coefficients");
398	–	printf("-c%c\t\t\t\t# %s\n", accumulate ? '+' : '-',
399	–	accumulate ? "accumulate ray values" :
400	–	"one output record per ray");
388		fflush(stdout);                 /* report OUR options */
389		rtargv[rtargc++] = header ? "-h+" : "-h-";
390		sprintf(fmt, "-f%c%c", inpfmt, outfmt);
#	Line 554 | Line 541 | init(int np)
541		raysleft = yres;
542		} else
543		raysleft = 0;
544	+	if ((account = accumulate) > 0)
545	+	raysleft *= accumulate;
546		waitflush = xres;
547		if (!recover)
548		return;
549		/* recover previous values */
550	<	if (accumulate)
550	>	if (accumulate <= 0)
551		reload_output();
552		else
553		recover_output(stdin);
#	Line 591 | Line 580 | addmodifier(char *modn, char *outf, char *binv, int bi
580		error(USER, errmsg);
581		}
582		if (nmods >= MAXMODLIST)
583	<	error(USER, "too many modifiers");
583	>	error(INTERNAL, "too many modifiers");
584		modname[nmods++] = modn;        /* XXX assumes static string */
585		lep->key = modn;                /* XXX assumes static string */
586		mp = (MODCONT *)malloc(sizeof(MODCONT));
#	Line 599 | Line 588 | addmodifier(char *modn, char *outf, char *binv, int bi
588		error(SYSTEM, "out of memory in addmodifier");
589		mp->outspec = outf;             /* XXX assumes static string */
590		mp->modname = modn;             /* XXX assumes static string */
591	<	if (binv != NULL)
592	<	mp->binv = eparse(binv);
593	<	else
594	<	mp->binv = eparse("0");
595	<	mp->nbins = 1;
591	>	if (binv == NULL)
592	>	binv = "0";             /* use single bin if unspecified */
593	>	mp->binv = eparse(binv);
594	>	if (mp->binv->type == NUM) {    /* check value if constant */
595	>	bincnt = (int)(evalue(mp->binv) + 1.5);
596	>	if (bincnt != 1) {
597	>	sprintf(errmsg, "illegal non-zero constant for bin (%s)",
598	>	binv);
599	>	error(USER, errmsg);
600	>	}
601	>	}
602	>	mp->nbins = 1;                  /* initialize results holder */
603		setcolor(mp->cbin[0], 0., 0., 0.);
604	<	if (mp->binv->type == NUM)      /* assume one bin if constant */
609	<	bincnt = 1;
610	<	else if (bincnt > 1)
604	>	if (bincnt > 1)
605		mp = growmodifier(mp, bincnt);
606		lep->data = (char *)mp;
607		/* allocate output streams */
#	Line 670 | Line 664 | ofname(char *oname, const char *ospec, const char *mna
664		mnp = cp;
665		break;
666		case 'd':
667	+	case 'i':
668	+	case 'o':
669	+	case 'x':
670	+	case 'X':
671		if (bnp != NULL)
672		return -1;
673		bnp = cp;
#	Line 813 | Line 811 | getostream(const char *ospec, const char *mname, int b
811		*cp = '\0';
812		printheader(sop->ofp, info);
813		}
814	<	if (!accumulate) {              /* global res. for -c- */
814	>	if (accumulate > 0) {           /* global resolution */
815		sop->xr = xres; sop->yr = yres;
816		}
817		printresolu(sop->ofp, sop->xr, sop->yr);
818		/* play catch-up */
819	<	for (i = accumulate ? 0 : lastdone; i--; ) {
819	>	for (i = accumulate > 0 ? lastdone/accumulate : 0; i--; ) {
820		int     j = sop->reclen;
821		if (j <= 0) j = 1;
822		while (j--)
#	Line 960 | Line 958 | put_contrib(const DCOLOR cnt, FILE *fout)
958
959		/* output ray tallies and clear for next accumulation */
960		void
961	<	done_contrib(void)
961	>	done_contrib(int navg)
962		{
963	+	double          sf = 1.;
964		int             i, j;
965		MODCONT         *mp;
966		STREAMOUT       *sop;
967	+	/* set average scaling */
968	+	if (navg > 1)
969	+	sf = 1. / (double)navg;
970		/* output modifiers in order */
971		for (i = 0; i < nmods; i++) {
972		mp = (MODCONT *)lu_find(&modconttab,modname[i])->data;
973	+	if (navg > 1)                   /* average scaling */
974	+	for (j = mp->nbins; j--; )
975	+	scalecolor(mp->cbin[j], sf);
976		sop = getostream(mp->outspec, mp->modname, 0,0);
977		put_contrib(mp->cbin[0], sop->ofp);
978		if (mp->nbins > 3 &&            /* minor optimization */
#	Line 1051 | Line 1056 | process_queue(void)
1056		cp += sizeof(float)*9; n -= sizeof(float)*9;
1057		add_contrib(modname);
1058		}
1059	<	if (!accumulate)
1060	<	done_contrib(); /* sum up contributions & output */
1059	>	/* time to produce record? */
1060	>	if (account > 0 && !--account)
1061	>	done_contrib(account = accumulate);
1062		lastdone = rtp->raynum;
1063		if (rtp->buf != NULL)   /* free up buffer space */
1064		free(rtp->buf);
#	Line 1139 | Line 1145 | get_rproc(void)
1145		void
1146		trace_contribs(FILE *fin)
1147		{
1148	+	static int      ignore_warning_given = 0;
1149		char            inpbuf[128];
1150		int             iblen;
1151		struct rtproc   *rtp;
1152		/* loop over input */
1153		while ((iblen = getinp(inpbuf, fin)) >= 0) {
1154	<	if (!iblen ||                   /* need reset? */
1154	>	if (!iblen && accumulate != 1) {
1155	>	if (!ignore_warning_given++)
1156	>	error(WARNING,
1157	>	"dummy ray(s) ignored during accumulation\n");
1158	>	continue;
1159	>	}
1160	>	if (!iblen ||                   /* need flush/reset? */
1161		queue_length() > 10*nrtprocs() ||
1162		lastray+1 < lastray) {
1163		while (wait_rproc() != NULL)
#	Line 1157 | Line 1170 | trace_contribs(FILE *fin)
1170		if (iblen) {                    /* trace ray if valid */
1171		writebuf(rtp->pd.w, inpbuf, iblen);
1172		} else {                        /* else bypass dummy ray */
1173	<	queue_raytree(rtp);     /* empty tree */
1174	<	if ((yres <= 0) | (waitflush > 1))
1175	<	waitflush = 1;  /* flush after this */
1173	>	queue_raytree(rtp);     /* queue empty ray/record */
1174	>	if ((yres <= 0) | (xres <= 0))
1175	>	waitflush = 1;  /* flush right after */
1176		}
1177		process_queue();                /* catch up with results */
1178		if (raysleft && !--raysleft)
#	Line 1167 | Line 1180 | trace_contribs(FILE *fin)
1180		}
1181		while (wait_rproc() != NULL)            /* process outstanding rays */
1182		process_queue();
1183	<	if (accumulate)
1184	<	done_contrib();                 /* output tallies */
1183	>	if (accumulate <= 0)
1184	>	done_contrib(0);                /* output tallies */
1185	>	else if (account < accumulate) {
1186	>	error(WARNING, "partial accumulation in final record");
1187	>	done_contrib(accumulate - account);
1188	>	}
1189		if (raysleft)
1190		error(USER, "unexpected EOF on input");
1191		lu_done(&ofiletab);                     /* close output files */
#	Line 1210 | Line 1227 | myclose(const LUENT *e, void *p)
1227		STREAMOUT       *sop = (STREAMOUT *)e->data;
1228
1229		if (sop->ofp == NULL)
1230	<	return;
1230	>	return(0);
1231		fclose(sop->ofp);
1232		sop->ofp = NULL;
1233	+	return(0);
1234		}
1235
1236		/* load previously accumulated values */
#	Line 1463 | Line 1481 | recover_output(FILE *fin)
1481		error(WARNING, "no output files to recover");
1482		return;
1483		}
1484	<	if (raysleft && lastout >= raysleft) {
1484	>	if (raysleft && lastout >= raysleft/accumulate) {
1485		error(WARNING, "output appears to be complete");
1486		/* XXX should read & discard input? */
1487		quit(0);
#	Line 1475 | Line 1493 | recover_output(FILE *fin)
1493		for (nvals = 0; nvals < lastout; nvals++)
1494		if (getinp(oname, fin) < 0)
1495		error(USER, "unexpected EOF on input");
1496	<	lastray = lastdone = (unsigned long)lastout;
1496	>	lastray = lastdone = (unsigned long)lastout * accumulate;
1497		if (raysleft)
1498		raysleft -= lastray;
1499		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)