--- ray/src/util/rtcontrib.c 2005/06/09 18:27:44 1.15 +++ ray/src/util/rtcontrib.c 2010/09/26 15:44:00 1.57 @@ -1,5 +1,5 @@ #ifndef lint -static const char RCSid[] = "$Id: rtcontrib.c,v 1.15 2005/06/09 18:27:44 greg Exp $"; +static const char RCSid[] = "$Id: rtcontrib.c,v 1.57 2010/09/26 15:44:00 greg Exp $"; #endif /* * Gather rtrace output to compute contributions from particular sources @@ -14,18 +14,21 @@ static const char RCSid[] = "$Id: rtcontrib.c,v 1.15 2 #include "color.h" #include "resolu.h" #include "lookup.h" +#include "random.h" #include "calcomp.h" +#ifndef MAXMODLIST #define MAXMODLIST 1024 /* maximum modifiers we'll track */ +#endif int treebufsiz = BUFSIZ; /* current tree buffer size */ typedef double DCOLOR[3]; /* double-precision color */ /* - * The modcont structure is used to accumulate ray contributions + * The MODCONT structure is used to accumulate ray contributions * for a particular modifier, which may be subdivided into bins - * if binv is non-NULL. 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 @@ -44,17 +47,41 @@ static void mcfree(void *p) { epfree((*(MODCONT *)p).b LUTAB modconttab = LU_SINIT(NULL,mcfree); /* modifier lookup table */ -/* close output stream */ -static void closefile(void *p) { fclose((FILE *)p); } +/* + * The STREAMOUT structure holds an open FILE pointer and a count of + * 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; -LUTAB ofiletab = LU_SINIT(free,closefile); /* output file table */ +/* close output stream and free record */ +static void +closestream(void *p) +{ + STREAMOUT *sop = (STREAMOUT *)p; + int status; + if (sop->outpipe) + status = pclose(sop->ofp); + else + status = fclose(sop->ofp); + if (status) + error(SYSTEM, "error closing output stream"); + free(p); +} +LUTAB ofiletab = LU_SINIT(free,closestream); /* output file table */ + #define OF_MODIFIER 01 #define OF_BIN 02 -FILE *getofile(const char *ospec, const char *mname, int bn); +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, int xr, int yr); /* * The rcont structure is used to manage i/o with a particular @@ -72,18 +99,28 @@ struct rtproc { }; /* rtrace process buffer */ /* rtrace command and defaults */ -char *rtargv[256] = { "rtrace", "-dj", ".5", "-dr", "3", - "-ab", "1", "-ad", "128", }; +char *rtargv[256+2*MAXMODLIST] = { "rtrace", + "-dj", ".9", "-dr", "3", + "-ab", "1", "-ad", "350", }; + int rtargc = 9; /* overriding rtrace options */ -char *myrtopts[] = { "-o~~TmWdp", "-h-", "-x", "1", "-y", "0", +char *myrtopts[] = { "-h-", "-x", "1", "-y", "0", "-dt", "0", "-as", "0", "-aa", "0", NULL }; +#define RTCOEFF "-o~~TmWdp" /* compute coefficients only */ +#define RTCONTRIB "-o~~TmVdp" /* compute ray contributions */ + 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 */ @@ -95,9 +132,13 @@ int inpfmt = 'a'; /* input format */ int outfmt = 'a'; /* output format */ int header = 1; /* output header? */ +int force_open = 0; /* truncate existing output? */ +int recover = 0; /* recover previous output? */ +int accumulate = 1; /* input rays per output record */ int xres = 0; /* horiz. output resolution */ int yres = 0; /* vert. output resolution */ +int account; /* current accumulation count */ unsigned long raysleft; /* number of rays left to trace */ long waitflush; /* how long until next flush */ @@ -109,10 +150,15 @@ int using_stdout = 0; /* are we using stdout? */ const char *modname[MAXMODLIST]; /* ordered modifier name list */ int nmods = 0; /* number of modifiers */ -MODCONT *addmodifier(char *modn, char *outf, char *binv); +#define queue_length() (lastray - lastdone) +MODCONT *growmodifier(MODCONT *mp, int nb); +MODCONT *addmodifier(char *modn, char *outf, char *binv, int bincnt); +void addmodfile(char *fname, char *outf, char *binv, int bincnt); + 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); @@ -122,8 +168,20 @@ void process_queue(void); void put_contrib(const DCOLOR cnt, FILE *fout); void add_contrib(const char *modn); -void done_contrib(void); +void done_contrib(int navg); +/* return number of open rtrace processes */ +static int +nrtprocs(void) +{ + int nrtp = 0; + struct rtproc *rtp; + + for (rtp = &rt0; rtp != NULL; rtp = rtp->next) + nrtp += rtp->pd.running; + return(nrtp); +} + /* set input/output format */ static void setformat(const char *fmt) @@ -163,12 +221,20 @@ fmterr: int main(int argc, char *argv[]) { + int contrib = 0; int nprocs = 1; - int recover = 0; char *curout = NULL; char *binval = NULL; + int bincnt = 0; char fmt[8]; int i, j; + /* need at least one argument */ + if (argc < 2) { + fprintf(stderr, +"Usage: %s [-n nprocs][-V][-r][-e expr][-f source][-o ospec][-b binv] {-m mod | -M file} [rtrace options] octree\n", + argv[0]); + exit(1); + } /* global program name */ gargv = argv; /* initialize calcomp routines */ @@ -181,22 +247,43 @@ main(int argc, char *argv[]) while ((j = expandarg(&argc, &argv, i)) > 0) ; if (j < 0) { - fprintf(stderr, "%s: cannot expand '%s'", + fprintf(stderr, "%s: cannot expand '%s'\n", argv[0], argv[i]); exit(1); } if (argv[i][0] == '-') switch (argv[i][1]) { - case 'r': /* recover output */ - if (argv[i][2]) break; - recover++; - continue; case 'n': /* number of processes */ - if (argv[i][2] || i >= argc-1) break; + if (argv[i][2] || i >= argc-2) break; nprocs = atoi(argv[++i]); if (nprocs <= 0) error(USER, "illegal number of processes"); continue; + case 'V': /* output contributions */ + switch (argv[i][2]) { + case '\0': + contrib = !contrib; + continue; + case '+': case '1': + case 'T': case 't': + case 'Y': case 'y': + contrib = 1; + continue; + case '-': case '0': + case 'F': case 'f': + case 'N': case 'n': + contrib = 0; + continue; + } + break; + case 'c': /* input rays per output */ + if (argv[i][2] || i >= argc-2) break; + accumulate = atoi(argv[++i]); + continue; + case 'r': /* recover output */ + if (argv[i][2]) break; + recover = 1; + continue; case 'h': /* output header? */ switch (argv[i][2]) { case '\0': @@ -214,10 +301,10 @@ main(int argc, char *argv[]) continue; } break; - case 'f': /* file or i/o format */ + case 'f': /* file or force or format */ if (!argv[i][2]) { char *fpath; - if (i >= argc-1) break; + if (i >= argc-2) break; fpath = getpath(argv[++i], getrlibpath(), R_OK); if (fpath == NULL) { @@ -229,48 +316,79 @@ main(int argc, char *argv[]) fcompile(fpath); continue; } + if (argv[i][2] == 'o') { + force_open = 1; + continue; + } setformat(argv[i]+2); continue; case 'e': /* expression */ - if (argv[i][2] || i >= argc-1) break; + if (argv[i][2] || i >= argc-2) break; scompile(argv[++i], NULL, 0); continue; case 'o': /* output file spec. */ - if (argv[i][2] || i >= argc-1) break; + if (argv[i][2] || i >= argc-2) break; curout = argv[++i]; continue; case 'x': /* horiz. output resolution */ - if (argv[i][2] || i >= argc-1) break; + if (argv[i][2] || i >= argc-2) break; xres = atoi(argv[++i]); continue; case 'y': /* vert. output resolution */ - if (argv[i][2] || i >= argc-1) break; + if (argv[i][2] || i >= argc-2) break; yres = atoi(argv[++i]); continue; - case 'b': /* bin expression */ - if (argv[i][2] || i >= argc-1) break; + case 'b': /* bin expression/count */ + if (i >= argc-2) break; + if (argv[i][2] == 'n') { + bincnt = (int)(eval(argv[++i]) + .5); + continue; + } + if (argv[i][2]) break; binval = argv[++i]; continue; case 'm': /* modifier name */ - if (argv[i][2] || i >= argc-1) break; + if (argv[i][2] || i >= argc-2) break; rtargv[rtargc++] = "-ti"; rtargv[rtargc++] = argv[++i]; - addmodifier(argv[i], curout, binval); + addmodifier(argv[i], curout, binval, bincnt); continue; + case 'M': /* modifier file */ + if (argv[i][2] || i >= argc-2) break; + rtargv[rtargc++] = "-tI"; + rtargv[rtargc++] = argv[++i]; + addmodfile(argv[i], curout, binval, bincnt); + continue; + case 'P': /* persist file */ + 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 <= 0) /* no output flushing for single record */ + xres = yres = 0; /* set global argument list */ gargc = argc; gargv = argv; /* add "mandatory" rtrace settings */ for (j = 0; myrtopts[j] != NULL; j++) rtargv[rtargc++] = myrtopts[j]; + rtargv[rtargc++] = contrib ? RTCONTRIB : RTCOEFF; /* just asking for defaults? */ if (!strcmp(argv[i], "-defaults")) { - char sxres[16], syres[16]; + char nps[8], sxres[16], syres[16]; char *rtpath; - printf("-n %-2d\t\t\t\t# number of processes\n", nprocs); + printf("-c %-5d\t\t\t# accumulated rays per record\n", + accumulate); + printf("-V%c\t\t\t\t# output %s\n", contrib ? '+' : '-', + contrib ? "contributions" : "coefficients"); fflush(stdout); /* report OUR options */ + rtargv[rtargc++] = "-n"; + sprintf(nps, "%d", nprocs); + rtargv[rtargc++] = nps; rtargv[rtargc++] = header ? "-h+" : "-h-"; sprintf(fmt, "-f%c%c", inpfmt, outfmt); rtargv[rtargc++] = fmt; @@ -280,7 +398,6 @@ main(int argc, char *argv[]) rtargv[rtargc++] = "-y"; sprintf(syres, "%d", yres); rtargv[rtargc++] = syres; - rtargv[rtargc++] = "-oTW"; rtargv[rtargc++] = "-defaults"; rtargv[rtargc] = NULL; rtpath = getpath(rtargv[0], getenv("PATH"), X_OK); @@ -294,8 +411,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); @@ -305,20 +427,23 @@ main(int argc, char *argv[]) error(USER, "missing octree argument"); rtargv[rtargc++] = octree = argv[i]; rtargv[rtargc] = NULL; - /* start rtrace & compute contributions */ + /* start rtrace & recover if requested */ init(nprocs); - if (recover) /* perform recovery if requested */ - recover_output(stdin); + /* compute contributions */ trace_contribs(stdin); + /* clean up */ quit(0); } +#ifndef SIGALRM +#define SIGALRM SIGTERM +#endif /* kill persistent rtrace process */ static void killpersist(void) { FILE *fp = fopen(persistfn, "r"); - int pid; + RT_PID pid; if (fp == NULL) return; @@ -352,7 +477,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); @@ -419,39 +544,90 @@ init(int np) raysleft = yres; } else raysleft = 0; - waitflush = xres; + if ((account = accumulate) > 0) + raysleft *= accumulate; + waitflush = (yres > 0) & (xres > 1) ? 0 : xres; + if (!recover) + return; + /* recover previous values */ + if (accumulate <= 0) + reload_output(); + else + recover_output(stdin); } +/* grow modifier to accommodate more bins */ +MODCONT * +growmodifier(MODCONT *mp, int nb) +{ + if (nb <= mp->nbins) + return mp; + mp = (MODCONT *)realloc(mp, sizeof(MODCONT) + sizeof(DCOLOR)*(nb-1)); + if (mp == NULL) + error(SYSTEM, "out of memory in growmodifier"); + memset(mp->cbin+mp->nbins, 0, sizeof(DCOLOR)*(nb-mp->nbins)); + mp->nbins = nb; + return mp; +} + /* add modifier to our list to track */ MODCONT * -addmodifier(char *modn, char *outf, char *binv) +addmodifier(char *modn, char *outf, char *binv, int bincnt) { LUENT *lep = lu_find(&modconttab, modn); MODCONT *mp; + int i; if (lep->data != NULL) { sprintf(errmsg, "duplicate modifier '%s'", modn); error(USER, errmsg); } if (nmods >= MAXMODLIST) - error(USER, "too many modifiers"); + error(INTERNAL, "too many modifiers"); modname[nmods++] = modn; /* XXX assumes static string */ lep->key = modn; /* XXX assumes static string */ mp = (MODCONT *)malloc(sizeof(MODCONT)); if (mp == NULL) error(SYSTEM, "out of memory in addmodifier"); - lep->data = (char *)mp; mp->outspec = outf; /* XXX assumes static string */ mp->modname = modn; /* XXX assumes static string */ - if (binv != NULL) - mp->binv = eparse(binv); - else - mp->binv = eparse("0"); - mp->nbins = 1; + if (binv == NULL) + binv = "0"; /* use single bin if unspecified */ + mp->binv = eparse(binv); + if (mp->binv->type == NUM) { /* check value if constant */ + bincnt = (int)(evalue(mp->binv) + 1.5); + if (bincnt != 1) { + sprintf(errmsg, "illegal non-zero constant for bin (%s)", + binv); + error(USER, errmsg); + } + } + mp->nbins = 1; /* initialize results holder */ setcolor(mp->cbin[0], 0., 0., 0.); + if (bincnt > 1) + mp = growmodifier(mp, bincnt); + lep->data = (char *)mp; + /* allocate output streams */ + for (i = bincnt; i-- > 0; ) + getostream(mp->outspec, mp->modname, i, 1); return mp; } +/* add modifiers from a file list */ +void +addmodfile(char *fname, char *outf, char *binv, int bincnt) +{ + char *mname[MAXMODLIST]; + int i; + /* find the file & store strings */ + if (wordfile(mname, getpath(fname, getrlibpath(), R_OK)) < 0) { + sprintf(errmsg, "cannot find modifier file '%s'", fname); + error(SYSTEM, errmsg); + } + for (i = 0; mname[i]; i++) /* add each one */ + addmodifier(mname[i], outf, binv, bincnt); +} + /* put string to stderr */ void eputs(char *s) @@ -491,6 +667,10 @@ ofname(char *oname, const char *ospec, const char *mna mnp = cp; break; case 'd': + case 'i': + case 'o': + case 'x': + case 'X': if (bnp != NULL) return -1; bnp = cp; @@ -549,30 +729,42 @@ printheader(FILE *fout, const char *info) break; } fputc('\n', fout); - if (xres > 0) { - if (yres > 0) /* resolution string */ - fprtresolu(xres, yres, fout); - fflush(fout); - } } -/* Get output file pointer (open and write header if new) */ -FILE * -getofile(const char *ospec, const char *mname, int bn) +/* write resolution string to given output stream */ +void +printresolu(FILE *fout, int xr, int yr) { - int ofl; - char oname[1024]; - LUENT *lep; + if ((xr > 0) & (yr > 0)) /* resolution string */ + fprtresolu(xr, yr, 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]; + LUENT *lep; + STREAMOUT *sop; if (ospec == NULL) { /* use stdout? */ - if (!using_stdout) { + if (!noopen && !using_stdout) { if (outfmt != 'a') SET_FILE_BINARY(stdout); if (header) printheader(stdout, NULL); + printresolu(stdout, xres, yres); + if (waitflush > 0) + fflush(stdout); + stdos.xr = xres; stdos.yr = yres; + using_stdout = 1; } - using_stdout = 1; - return stdout; + stdos.ofp = stdout; + stdos.reclen += noopen; + return &stdos; } ofl = ofname(oname, ospec, mname, bn); /* get output name */ if (ofl < 0) { @@ -582,23 +774,36 @@ getofile(const char *ospec, const char *mname, int bn) lep = lu_find(&ofiletab, oname); /* look it up */ if (lep->key == NULL) /* new entry */ lep->key = strcpy((char *)malloc(strlen(oname)+1), oname); - if (lep->data == NULL) { /* open output file */ - FILE *fp; - int i; - if (oname[0] == '!') /* output to command */ - fp = popen(oname+1, "w"); - else - fp = fopen(oname, "w"); - if (fp == NULL) { - sprintf(errmsg, "cannot open '%s' for writing", oname); - error(SYSTEM, errmsg); + sop = (STREAMOUT *)lep->data; + if (sop == NULL) { /* allocate stream */ + sop = (STREAMOUT *)malloc(sizeof(STREAMOUT)); + if (sop == NULL) + error(SYSTEM, "out of memory in getostream"); + 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 /* else open file */ + sop->ofp = fopen(oname, "w"); + if (sop->ofp == NULL) + goto openerr; if (outfmt != 'a') - SET_FILE_BINARY(fp); + SET_FILE_BINARY(sop->ofp); if (header) { char info[512]; char *cp = info; - if (ofl & OF_MODIFIER) { + if (ofl & OF_MODIFIER || sop->reclen == 1) { sprintf(cp, "MODIFIER=%s\n", mname); while (*cp) ++cp; } @@ -607,26 +812,38 @@ getofile(const char *ospec, const char *mname, int bn) while (*cp) ++cp; } *cp = '\0'; - printheader(fp, info); + printheader(sop->ofp, info); } + if (accumulate > 0) { /* global resolution */ + sop->xr = xres; sop->yr = yres; + } + printresolu(sop->ofp, sop->xr, sop->yr); /* play catch-up */ - for (i = 0; i < lastdone; i++) { - static const DCOLOR nocontrib = BLKCOLOR; - put_contrib(nocontrib, fp); + for (i = accumulate > 0 ? lastdone/accumulate : 0; i--; ) { + int j = sop->reclen; + if (j <= 0) j = 1; + while (j--) + put_contrib(nocontrib, sop->ofp); if (outfmt == 'a') - putc('\n', fp); + putc('\n', sop->ofp); } - if (xres > 0) - fflush(fp); - lep->data = (char *)fp; + if (waitflush > 0) + fflush(sop->ofp); } - return (FILE *)lep->data; /* return open file pointer */ + 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], *dvp; + float *fvp; char *cp; int i; @@ -635,25 +852,35 @@ getinp(char *buf, FILE *fp) cp = buf; /* make sure we get 6 floats */ for (i = 0; i < 6; i++) { if (fgetword(cp, buf+127-cp, fp) == NULL) - return 0; + return -1; + if (i >= 3) + dv[i-3] = atof(cp); if ((cp = fskip(cp)) == NULL || *cp) - return 0; + return -1; *cp++ = ' '; } getc(fp); /* get/put eol */ *cp-- = '\0'; *cp = '\n'; + if (DOT(dv,dv) <= FTINY*FTINY) + return 0; /* dummy ray */ return strlen(buf); case 'f': if (fread(buf, sizeof(float), 6, fp) < 6) - return 0; + return -1; + 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 0; + return -1; + dvp = (double *)buf + 3; + if (DOT(dvp,dvp) <= FTINY*FTINY) + return 0; /* dummy ray */ return sizeof(double)*6; } error(INTERNAL, "botched input format"); - return 0; /* pro forma return */ + return -1; /* pro forma return */ } static float rparams[9]; /* traced ray parameters */ @@ -683,15 +910,8 @@ add_contrib(const char *modn) bn = (int)(evalue(mp->binv) + .5); if (bn <= 0) bn = 0; - else if (bn > mp->nbins) { /* new bin */ - mp = (MODCONT *)realloc(mp, sizeof(MODCONT) + - bn*sizeof(DCOLOR)); - if (mp == NULL) - error(SYSTEM, "out of memory in add_contrib"); - memset(mp->cbin+mp->nbins, 0, sizeof(DCOLOR)*(bn+1-mp->nbins)); - mp->nbins = bn+1; - le->data = (char *)mp; - } + else if (bn >= mp->nbins) /* new bin */ + le->data = (char *)(mp = growmodifier(mp, bn+1)); addcolor(mp->cbin[bn], rparams); } @@ -699,13 +919,13 @@ add_contrib(const char *modn) static int puteol(const LUENT *e, void *p) { - FILE *fp = (FILE *)e->data; + STREAMOUT *sop = (STREAMOUT *)e->data; if (outfmt == 'a') - putc('\n', fp); + putc('\n', sop->ofp); if (!waitflush) - fflush(fp); - if (ferror(fp)) { + fflush(sop->ofp); + if (ferror(sop->ofp)) { sprintf(errmsg, "write error on file '%s'", e->key); error(SYSTEM, errmsg); } @@ -724,9 +944,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': @@ -739,29 +957,38 @@ put_contrib(const DCOLOR cnt, FILE *fout) default: error(INTERNAL, "botched output format"); } + if (waitflush < 0 && frandom() < 0.001) + fflush(fout); /* staggers writes */ } -/* output ray tallies and clear for next primary */ +/* output ray tallies and clear for next accumulation */ void -done_contrib(void) +done_contrib(int navg) { - int i, j; - MODCONT *mp; - FILE *fp; + double sf = 1.; + int i, j; + MODCONT *mp; + STREAMOUT *sop; + /* set average scaling */ + if (navg > 1) + sf = 1. / (double)navg; /* output modifiers in order */ for (i = 0; i < nmods; i++) { mp = (MODCONT *)lu_find(&modconttab,modname[i])->data; - fp = getofile(mp->outspec, mp->modname, 0); - put_contrib(mp->cbin[0], fp); + if (navg > 1) /* average scaling */ + for (j = mp->nbins; j--; ) + scalecolor(mp->cbin[j], sf); + sop = getostream(mp->outspec, mp->modname, 0,0); + put_contrib(mp->cbin[0], sop->ofp); if (mp->nbins > 3 && /* minor optimization */ - fp == getofile(mp->outspec, mp->modname, 1)) + sop == getostream(mp->outspec, mp->modname, 1,0)) for (j = 1; j < mp->nbins; j++) - put_contrib(mp->cbin[j], fp); + put_contrib(mp->cbin[j], sop->ofp); else for (j = 1; j < mp->nbins; j++) put_contrib(mp->cbin[j], - getofile(mp->outspec, mp->modname, j)); - /* clear for next ray tree */ + getostream(mp->outspec,mp->modname,j,0)->ofp); + /* clear for next time */ memset(mp->cbin, 0, sizeof(DCOLOR)*mp->nbins); } --waitflush; /* terminate records */ @@ -769,7 +996,7 @@ done_contrib(void) if (using_stdout & (outfmt == 'a')) putc('\n', stdout); if (!waitflush) { - waitflush = xres; + waitflush = (yres > 0) & (xres > 1) ? 0 : xres; if (using_stdout) fflush(stdout); } @@ -820,7 +1047,9 @@ process_queue(void) if (!n || !(isalpha(*cp) | (*cp == '_'))) error(USER, "bad modifier name from rtrace"); /* get modifier name */ - while (n > 0 && *cp != '\t') { + while (n > 1 && *cp != '\t') { + if (mnp - modname >= sizeof(modname)-2) + error(INTERNAL, "modifier name too long"); *mnp++ = *cp++; n--; } *mnp = '\0'; @@ -832,9 +1061,12 @@ process_queue(void) cp += sizeof(float)*9; n -= sizeof(float)*9; add_contrib(modname); } - done_contrib(); /* sum up contributions & output */ + /* time to produce record? */ + if (account > 0 && !--account) + done_contrib(account = accumulate); lastdone = rtp->raynum; - free(rtp->buf); /* free up buffer space */ + if (rtp->buf != NULL) /* free up buffer space */ + free(rtp->buf); rt_unproc = rtp->next; free(rtp); /* done with this ray tree */ } @@ -882,7 +1114,7 @@ wait_rproc(void) if (rt->bsiz + BUFSIZ <= treebufsiz) rt->bsiz = treebufsiz; else - rt->bsiz = treebufsiz += BUFSIZ; + treebufsiz = rt->bsiz += BUFSIZ; rt->buf = (char *)realloc(rt->buf, rt->bsiz); } if (rt->buf == NULL) @@ -918,54 +1150,230 @@ get_rproc(void) void trace_contribs(FILE *fin) { + static int ignore_warning_given = 0; char inpbuf[128]; int iblen; struct rtproc *rtp; /* loop over input */ - while ((iblen = getinp(inpbuf, fin)) > 0) { - if (lastray+1 < lastray) { /* counter rollover? */ + while ((iblen = getinp(inpbuf, fin)) >= 0) { + if (!iblen && accumulate != 1) { + if (!ignore_warning_given++) + error(WARNING, + "dummy ray(s) ignored during accumulation\n"); + continue; + } + if (!iblen || /* need flush/reset? */ + queue_length() > 10*nrtprocs() || + lastray+1 < lastray) { while (wait_rproc() != NULL) process_queue(); - lastdone = lastray = 0; + if (lastray+1 < lastray) + lastdone = lastray = 0; } rtp = get_rproc(); /* get avail. rtrace process */ - rtp->raynum = ++lastray; /* assign ray to it */ - writebuf(rtp->pd.w, inpbuf, iblen); - if (raysleft && !--raysleft) - break; + rtp->raynum = ++lastray; /* assign ray */ + if (iblen) { /* trace ray if valid */ + writebuf(rtp->pd.w, inpbuf, iblen); + } else { /* else bypass dummy ray */ + queue_raytree(rtp); /* queue empty ray/record */ + if ((yres <= 0) | (xres <= 0)) + waitflush = 1; /* flush right after */ + } process_queue(); /* catch up with results */ + if (raysleft && !--raysleft) + break; /* preemptive EOI */ } while (wait_rproc() != NULL) /* process outstanding rays */ process_queue(); + if (accumulate <= 0) + done_contrib(0); /* output tallies */ + else if (account < accumulate) { + error(WARNING, "partial accumulation in final record"); + done_contrib(accumulate - account); + } 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(0); + fclose(sop->ofp); + sop->ofp = NULL; + return(0); +} + +/* 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) { - if (fseeko((FILE *)e->data, *(off_t *)p, SEEK_CUR) < 0) { + STREAMOUT *sop = (STREAMOUT *)e->data; + off_t nbytes = *(off_t *)p; + + if (sop->reclen > 1) + nbytes = nbytes * sop->reclen; + if (fseeko(sop->ofp, nbytes, SEEK_CUR) < 0) { sprintf(errmsg, "seek error on file '%s'", e->key); error(SYSTEM, errmsg); } + return 0; } /* recover output if possible */ void recover_output(FILE *fin) { - off_t lastout = -1; - int outvsiz; - char *outvfmt; - int i, j; - MODCONT *mp; - int ofl; - char oname[1024]; - LUENT *ment, *oent; - FILE *fp; - off_t nvals; + off_t lastout = -1; + int outvsiz, recsiz; + char *outvfmt; + int i, j; + MODCONT *mp; + int ofl; + char oname[1024]; + LUENT *ment, *oent; + STREAMOUT sout; + off_t nvals; + int xr, yr; switch (outfmt) { case 'a': @@ -993,84 +1401,104 @@ recover_output(FILE *fin) mp = (MODCONT *)ment->data; if (mp->outspec == NULL) error(USER, "cannot recover from stdout"); + if (mp->outspec[0] == '!') + error(USER, "cannot recover from command"); for (j = 0; ; j++) { /* check each bin's file */ 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) { /* saw this one already */ + if (oent->data != NULL) { + sout = *(STREAMOUT *)oent->data; + } else { + sout.reclen = 0; + sout.outpipe = 0; + sout.ofp = NULL; + } + if (sout.ofp != NULL) { /* already open? */ if (ofl & OF_BIN) continue; break; } - if (oname[0] == '!') - error(USER, "cannot recover from command"); /* open output */ - fp = fopen(oname, "rb+"); - if (fp == NULL) - break; /* must be end of modifier */ - nvals = lseek(fileno(fp), 0, SEEK_END); + sout.ofp = fopen(oname, "rb+"); + if (sout.ofp == NULL) { + if (j) + break; /* assume end of modifier */ + sprintf(errmsg, "missing recover file '%s'", + oname); + error(WARNING, errmsg); + break; + } + nvals = lseek(fileno(sout.ofp), 0, SEEK_END); if (nvals <= 0) { lastout = 0; /* empty output, quit here */ - fclose(fp); + fclose(sout.ofp); break; } - lseek(fileno(fp), 0, SEEK_SET); - if (header) { - int xr, yr; - if (checkheader(fp, outvfmt, NULL) != 1) { + if (!sout.reclen) { + if (!(ofl & OF_BIN)) { sprintf(errmsg, - "format mismatch for '%s'", + "need -bn to recover file '%s'", oname); error(USER, errmsg); } - if (xres > 0 && yres > 0 && - (!fscnresolu(&xr, &yr, fp) || - xr != xres || - yr != yres)) { - sprintf(errmsg, - "resolution mismatch for '%s'", - oname); - error(USER, errmsg); - } + recsiz = outvsiz; + } else + recsiz = outvsiz * sout.reclen; + + lseek(fileno(sout.ofp), 0, SEEK_SET); + if (header && checkheader(sout.ofp, outvfmt, NULL) != 1) { + sprintf(errmsg, "format mismatch for '%s'", + oname); + error(USER, errmsg); } - nvals = (nvals - (off_t)ftell(fp)) / outvsiz; - if (lastout < 0 || nvals < lastout) + sout.xr = xres; sout.yr = yres; + 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); + } + nvals = (nvals - (off_t)ftell(sout.ofp)) / recsiz; + if ((lastout < 0) | (nvals < lastout)) lastout = nvals; - if (oent->key == NULL) /* new entry */ + if (oent->key == NULL) /* new entry */ oent->key = strcpy((char *) malloc(strlen(oname)+1), oname); - oent->data = (char *)fp; + if (oent->data == NULL) + oent->data = (char *)malloc(sizeof(STREAMOUT)); + *(STREAMOUT *)oent->data = sout; if (!(ofl & OF_BIN)) break; /* no bin separation */ } if (!lastout) { /* empty output */ - error(WARNING, "no data to recover"); + error(WARNING, "no previous data to recover"); lu_done(&ofiletab); /* reclose all outputs */ return; } - if (j > mp->nbins) { /* preallocate modifier bins */ - mp = (MODCONT *)realloc(mp, sizeof(MODCONT) + - (j-1)*sizeof(DCOLOR)); - if (mp == NULL) - error(SYSTEM, "out of memory in recover_output"); - memset(mp->cbin, 0, sizeof(DCOLOR)*mp->nbins); - mp->nbins = j; - ment->data = (char *)mp; - } + if (j > mp->nbins) /* reallocate modifier bins */ + ment->data = (char *)(mp = growmodifier(mp, j)); } if (lastout < 0) { - error(WARNING, "no existing output to recover"); + error(WARNING, "no output files to recover"); return; } + if (raysleft && lastout >= raysleft/accumulate) { + error(WARNING, "output appears to be complete"); + /* XXX should read & discard input? */ + quit(0); + } /* seek on all files */ nvals = lastout * outvsiz; lu_doall(&ofiletab, myseeko, &nvals); - /* discard input */ + /* skip repeated input */ for (nvals = 0; nvals < lastout; nvals++) - if (getinp(oname, fin) <= 0) + if (getinp(oname, fin) < 0) error(USER, "unexpected EOF on input"); - lastray = lastdone = (unsigned long)lastout; + lastray = lastdone = (unsigned long)lastout * accumulate; if (raysleft) raysleft -= lastray; }