src/rt/rxcmain.cpp

#ifndef lint
static const char       RCSid[] = "$Id: rxcmain.cpp,v 2.19 2025/10/16 18:36:23 greg Exp $";
#endif
/*
 *  rxcmain.c - main for rxcontrib ray contribution tracer
 */

#include "copyright.h"

#include <signal.h>
#include <time.h>
#include <ctype.h>
#include "RcontribSimulManager.h"
#include "platform.h"
#include "func.h"

const char      *sigerr[NSIG];          /* signal error messages */

int     nproc = 1;                      /* number of processes requested */

int     inpfmt = 'a';                   /* input format */
int     outfmt = 'f';                   /* output format */

int     report_intvl = 0;               /* reporting interval (seconds) */

RcontribSimulManager    myRCmanager;    // global rcontrib simulation manager

#define RCONTRIB_FEATURES       "Multiprocessing\n" \
                                "Accumulation\nRecovery\n" \
                                "ImmediateIrradiance\n" \
                                "ProgressReporting\nDistanceLimiting\n" \
                                "InputFormats=a,f,d\nOutputFormats=f,d,c\n" \
                                "Outputs=V,W\n" \
                                "OutputCS=RGB,spec\n"

static void     rxcontrib(const int rstart = 0);

static void
printdefaults(void)                     /* print default values to stdout */
{
        printf("-c %-5d\t\t\t# accumulated rays per record\n", myRCmanager.accum);
        printf(myRCmanager.HasFlag(RCcontrib) ?
                        "-V+\t\t\t\t# output contributions\n" :
                        "-V-\t\t\t\t# output coefficients\n");
        if (myRCmanager.HasFlag(RTimmIrrad))
                printf("-I+\t\t\t\t# immediate irradiance on\n");
        printf("-n %-2d\t\t\t\t# number of rendering processes\n", nproc);
        printf("-x %-9d\t\t\t# x resolution\n", myRCmanager.xres);
        printf("-y %-9d\t\t\t# y resolution\n", myRCmanager.yres);
        printf(myRCmanager.HasFlag(RTlimDist) ?
                        "-ld+\t\t\t\t# limit distance on\n" :
                        "-ld-\t\t\t\t# limit distance off\n");
        printf("-f%c%c\t\t\t\t# format input/output = %s/%s\n",
                        inpfmt, outfmt, formstr(inpfmt), formstr(outfmt));
        if (report_intvl > 0)
                printf("-t %-9d\t\t\t# time between reports\n", report_intvl);
        printf(erract[WARNING].pf != NULL ?
                        "-w+\t\t\t\t# warning messages on\n" :
                        "-w-\t\t\t\t# warning messages off\n");
        print_rdefaults();
}


static void
onsig(                          /* fatal signal */
        int  signo
)
{
        static int  gotsig = 0;

        if (gotsig++)                   /* two signals and we're gone! */
                _exit(signo);

#ifdef SIGALRM
        alarm(600);                     /* allow 10 minutes to clean up */
        signal(SIGALRM, SIG_DFL);       /* make certain we do die */
#endif
        eputs("signal - ");
        eputs(sigerr[signo]);
        eputs("\n");
        quit(3);
}


static void
sigdie(                 /* set fatal signal */
        int  signo,
        const char  *msg
)
{
        if (signal(signo, onsig) == SIG_IGN)
                signal(signo, SIG_IGN);
        sigerr[signo] = msg;
}

/* set input/output format */
static void
setformat(const char *fmt)
{
        switch (fmt[0]) {
        case 'f':
        case 'd':
                SET_FILE_BINARY(stdin);
                /* fall through */
        case 'a':
                inpfmt = fmt[0];
                break;
        default:
                goto fmterr;
        }
        switch (fmt[1]) {
        case '\0':
                if (inpfmt == 'a')
                        goto fmterr;
                outfmt = inpfmt;
                return;
        case 'f':
        case 'd':
        case 'c':
                outfmt = fmt[1];
                break;
        default:
                goto fmterr;
        }
        if (!fmt[2])
                return;
fmterr:
        sprintf(errmsg, "Unsupported i/o format: -f%s", fmt);
        error(USER, errmsg);
}

/* Set default options */
static void
default_options(void)
{
        rand_samp = 1;
        dstrsrc = 0.9;
        directrelay = 3;
        vspretest = 512;
        srcsizerat = .2;
        specthresh = .02;
        specjitter = 1.;
        maxdepth = -10;
        minweight = 2e-3;
        ambres = 256;
        ambdiv = 350;
        ambounce = 1;
}

/* Set overriding options */
static void
override_options(void)
{
        shadthresh = 0;
        ambssamp = 0;
        ambacc = 0;
}

int
main(int argc, char *argv[])
{
#define  check(ol,al)           if (argv[i][ol] || \
                                badarg(argc-i-1,argv+i+1,al)) \
                                goto badopt
#define  check_bool(olen,var)           switch (argv[i][olen]) { \
                                case '\0': var = !var; break; \
                                case 'y': case 'Y': case 't': case 'T': \
                                case '+': case '1': var = 1; break; \
                                case 'n': case 'N': case 'f': case 'F': \
                                case '-': case '0': var = 0; break; \
                                default: goto badopt; }
        int     force_open = 0;
        int     recover = 0;
        char    *curout = NULL;
        char    *prms = NULL;
        char    *binval = NULL;
        int     bincnt = 0;
        int     rval;
        int     i;
                                        /* global program name */
        progname = argv[0];
                                        /* feature check only? */
        strcat(RFeatureList, RCONTRIB_FEATURES);
        if (argc > 1 && !strcmp(argv[1], "-features"))
                return feature_status(argc-2, argv+2);
                                        /* initialize calcomp routines early */
        initfunc();
        calcontext(RCCONTEXT);
                                        /* set rcontrib defaults */
        default_options();
                                        /* option city */
        for (i = 1; i < argc; i++) {
                                                /* expand arguments */
                while ((rval = expandarg(&argc, &argv, i)) > 0)
                        ;
                if (rval < 0) {
                        sprintf(errmsg, "cannot expand '%s'", argv[i]);
                        error(SYSTEM, errmsg);
                }
                if (argv[i] == NULL || argv[i][0] != '-')
                        break;                  /* break from options */
                if (!strcmp(argv[i], "-version")) {
                        puts(VersionID);
                        quit(0);
                }
                if (!strcmp(argv[i], "-defaults") ||
                                !strcmp(argv[i], "-help")) {
                        override_options();
                        printdefaults();
                        quit(0);
                }
                rval = getrenderopt(argc-i, argv+i);
                if (rval >= 0) {
                        i += rval;
                        continue;
                }
                switch (argv[i][1]) {
                case 'n':                       /* number of processes */
                        check(2,"i");
                        nproc = atoi(argv[++i]);
                        if (nproc < 0 && (nproc += RadSimulManager::GetNCores()) <= 0)
                                nproc = 1;
                        break;
                case 'V':                       /* output contributions? */
                        rval = myRCmanager.HasFlag(RCcontrib);
                        check_bool(2,rval);
                        myRCmanager.SetFlag(RCcontrib, rval);
                        break;
                case 'x':                       /* x resolution */
                        check(2,"i");
                        myRCmanager.xres = atoi(argv[++i]);
                        break;
                case 'y':                       /* y resolution */
                        check(2,"i");
                        myRCmanager.yres = atoi(argv[++i]);
                        break;
                case 'w':                       /* warnings on/off */
                        rval = (erract[WARNING].pf != NULL);
                        check_bool(2,rval);
                        if (rval) erract[WARNING].pf = wputs;
                        else erract[WARNING].pf = NULL;
                        break;
                case 'l':                       /* limit distance */
                        if (argv[i][2] != 'd')
                                goto badopt;
                        rval = myRCmanager.HasFlag(RTlimDist);
                        check_bool(3,rval);
                        myRCmanager.SetFlag(RTlimDist, rval);
                        break;
                case 'I':                       /* immed. irradiance */
                        rval = myRCmanager.HasFlag(RTimmIrrad);
                        check_bool(2,rval);
                        myRCmanager.SetFlag(RTimmIrrad, rval);
                        break;
                case 'f':                       /* force or format */
                        if (argv[i][2] == 'o') {
                                check_bool(3,force_open);
                                break;
                        }
                        setformat(argv[i]+2);
                        myRCmanager.SetDataFormat(outfmt);
                        break;
                case 'o':                       /* output file */
                        check(2,"s");
                        curout = argv[++i];
                        break;
                case 'r':                       /* recover output */
                        check_bool(2,recover);
                        break;
                case 'p':                       /* parameter setting(s) */
                        check(2,"s");
                        set_eparams(prms = argv[++i]);
                        break;
                case 'c':                       /* sample count */
                        check(2,"i");
                        myRCmanager.accum = atoi(argv[++i]);
                        break;
                case 'b':                       /* bin expression/count */
                        if (argv[i][2] == 'n') {
                                check(3,"s");
                                bincnt = (int)(eval(argv[++i]) + .5);
                                break;
                        }
                        check(2,"s");
                        binval = argv[++i];
                        break;
                case 'm':                       /* modifier name */
                        check(2,"s");
                        if (!myRCmanager.AddModifier(argv[++i], curout, prms, binval, bincnt)) {
                                sprintf(errmsg, "bad settings for modifier '%s'", argv[i]);
                                error(USER, errmsg);
                        }
                        break;
                case 'M':                       /* file of modifier names */
                        check(2,"s");
                        if (!myRCmanager.AddModFile(argv[++i], curout, prms, binval, bincnt)) {
                                sprintf(errmsg, "bad settings for modifier file '%s'", argv[i]);
                                error(USER, errmsg);
                        }
                        break;
                case 't':                       /* reporting interval */
                        check(2,"i");
                        report_intvl = atoi(argv[++i]);
                        break;
                default:
                        goto badopt;
                }
        }
        if (i != argc-1)
                error(USER, "expected single octree argument");

        override_options();             /* override some option settings */

        if (!myRCmanager.GetOutput())   // check that we have work to do
                error(USER, "missing required modifier argument");
                                        // get ready to rock...
        if (setspectrsamp(CNDX, WLPART) < 0)
                error(USER, "unsupported spectral sampling");
                                        /* set up signal handling */
        sigdie(SIGINT, "Interrupt");
#ifdef SIGHUP
        sigdie(SIGHUP, "Hangup");
#endif
        sigdie(SIGTERM, "Terminate");
#ifdef SIGPIPE
        sigdie(SIGPIPE, "Broken pipe");
#endif
#ifdef SIGALRM
        sigdie(SIGALRM, "Alarm clock");
#endif
#ifdef  SIGXCPU
        sigdie(SIGXCPU, "CPU limit exceeded");
        sigdie(SIGXFSZ, "File size exceeded");
#endif
#ifdef  NICE
        nice(NICE);                     /* lower priority */
#endif
                                        // load octree
        myRCmanager.LoadOctree(argv[argc-1]);
                                        // add to header
        myRCmanager.AddHeader(argc-1, argv);
        {
                char    buf[128] = "SOFTWARE= ";
                strcpy(buf+10, VersionID);
                myRCmanager.AddHeader(buf);
        }
                                        // prepare output files
        if (recover)
                myRCmanager.outOp = RCOrecover;
        else if (force_open)
                myRCmanager.outOp = RCOforce;
        else
                myRCmanager.outOp = RCOnew;
                                        // rval = # rows recovered
        rval = myRCmanager.PrepOutput();

        if (rval < 0)                   // PrepOutput() failure?
                error(USER, "issue loading or creating output(s)");
                                        // in case we recovered everything
        if (rval >= myRCmanager.GetRowMax())
                error(WARNING, "nothing left to compute");
        else
                rxcontrib(rval);        // trace ray contributions (loop)

        quit(0);        // exit clean

badopt:
        fprintf(stderr,
"Usage: %s [-V][-c count][-r][-e expr][-f source][-o ospec][-p p1=V1,p2=V2][-b binv][-bn N] {-m mod | -M file} [rtrace options] octree\n",
                        progname);
        sprintf(errmsg, "command line error at '%s'", argv[i]);
        error(USER, errmsg);
        return(1);      /* pro forma return */

#undef  check
#undef  check_bool
}


// skip specified number of bytes, return false if EOF
static bool
skipBytes(int n2skip)
{
        while (n2skip-- > 0)
                if (getchar() == EOF)
                        return false;
        return true;
}


// skip specified number of whitespace-separated words, return false if EOF
static bool
skipWords(int n2skip)
{
        int     c;

        while (n2skip-- > 0) {
                do {
                        c = getchar();
                } while (isspace(c));
                do {
                        if (c == EOF) return false;
                        c = getchar();
                } while (!isspace(c));
        }
        return true;
}


// read a bundle of myRCmanager.accum ray origins and directions
static bool
getRayBundle(FVECT *orig_dir = NULL)
{
        int     n2go = myRCmanager.accum;

        switch (inpfmt) {
        case 'a':                       // ASCII input
                if (!orig_dir)
                        return skipWords(6*n2go);
                while (n2go-- > 0) {
                        if (scanf(FVFORMAT, &orig_dir[0][0],
                                        &orig_dir[0][1], &orig_dir[0][2]) != 3)
                                return false;
                        if (scanf(FVFORMAT, &orig_dir[1][0],
                                        &orig_dir[1][1], &orig_dir[1][2]) != 3)
                                return false;
                        orig_dir += 2;
                }
                break;
        case 'f':                       // float input
                if (!orig_dir)
                        return skipBytes(6*sizeof(float)*n2go);
#ifdef SMLFLT
                if (getbinary(orig_dir, sizeof(FVECT), 2*n2go, stdin) != 2*n2go)
                        return false;
                orig_dir += 2*n2go;
#else
                while (n2go-- > 0) {
                        float   fvecs[6];
                        if (getbinary(fvecs, sizeof(fvecs), 1, stdin) != 1)
                                return false;
                        for (int i = 6; i--; )
                                orig_dir[0][i] = fvecs[i];
                        orig_dir += 2;
                }
#endif
                break;
        case 'd':                       // double input
                if (!orig_dir)
                        return skipBytes(6*sizeof(double)*n2go);
#ifndef SMLFLT
                if (getbinary(orig_dir, sizeof(FVECT), 2*n2go, stdin) != 2*n2go)
                        return false;
                orig_dir += 2*n2go;
#else
                while (n2go-- > 0) {
                        double  dvecs[6];
                        if (getbinary(dvecs, sizeof(dvecs), 1, stdin) != 1)
                                return false;
                        for (int i = 6; i--; )
                                orig_dir[0][i] = dvecs[i];
                        orig_dir += 2;
                }
#endif
                break;
        default:
                error(INTERNAL, "unsupported format in getRayBundle()");
                return false;
        }
        n2go = myRCmanager.accum;       // normalize directions
        while (n2go-- > 0) {
                orig_dir -= 2;
                normalize(orig_dir[1]);
        }
        return true;
}


// Run loop to load data, report progress, etc.
void
rxcontrib(const int rstart)
{
        const int       totRows = myRCmanager.GetRowMax();
        FVECT *         odarr = (FVECT *)emalloc(sizeof(FVECT)*2*myRCmanager.accum);
        time_t          tstart, last_report;
        int             r = 0;

        while (r < rstart) {            // skip input rays already done
                if (!getRayBundle())
                        goto readerr;
                r++;
        }
        if (report_intvl > 0) {         // set up reporting
                if (r > 0) {
                        sprintf(errmsg, "recovered %.2f%% of total\n",
                                        100.*r/totRows);
                        eputs(errmsg);
                }
                last_report = tstart = time(0);
        }
                                        // start children as requested
        myRCmanager.SetThreadCount(nproc);

        while (r < totRows) {           // loop until done
                time_t  tnow;
                if (!getRayBundle(odarr))
                        goto readerr;
                if (myRCmanager.ComputeRecord(odarr) <= 0)
                        return;         // error reported, hopefully...
                r++;
                if (report_intvl <= 0)
                        continue;
                if (r == totRows)       // need to finish up?
                        myRCmanager.SetThreadCount(1);
                tnow = time(0);
                if ((r < totRows) & (tnow < last_report+report_intvl))
                        continue;
                sprintf(errmsg, "%.2f%% done after %.3f hours\n",
                                100.*myRCmanager.GetRowFinished()/totRows,
                                (1./3600.)*(tnow - tstart));
                eputs(errmsg);
                last_report = tnow;
        }
        efree(odarr);
        return;
readerr:
        sprintf(errmsg, "unexpected EOF on standard input (record %d of %d)",
                        r, totRows);
        error(USER, errmsg);
}


void
wputs(                          /* warning output function */
        const char      *s
)
{
        if (!erract[WARNING].pf) return;
        int  lasterrno = errno;
        eputs(s);
        errno = lasterrno;
}


void
eputs(                          /* put string to stderr */
        const char  *s
)
{
        static int  midline = 0;

        if (!*s)
                return;
        if (!midline++) {
                fputs(progname, stderr);
                fputs(": ", stderr);
        }
        fputs(s, stderr);
        if (s[strlen(s)-1] == '\n') {
                fflush(stderr);
                midline = 0;
        }
}


/* Exit program */
void
quit(
        int  code
)
{
        myRCmanager.FlushQueue();       // leave nothing in queue

        exit(code);
}
Revision:	2.20
Committed:	Fri Oct 17 01:15:53 2025 UTC (8 days ago) by greg
Branch:	MAIN
Changes since 2.19:	+9 -3 lines
Log Message:	perf(rxcontrib): Added handshake to ensure each row is complete in children
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.20	static const char RCSid[] = "$Id: rxcmain.cpp,v 2.19 2025/10/16 18:36:23 greg Exp $";
3	greg	2.1	#endif
4			/*
5			* rxcmain.c - main for rxcontrib ray contribution tracer
6			*/
7
8			#include "copyright.h"
9
10			#include <signal.h>
11			#include <time.h>
12			#include <ctype.h>
13			#include "RcontribSimulManager.h"
14			#include "platform.h"
15			#include "func.h"
16
17			const char sigerr[NSIG]; / signal error messages */
18
19			int nproc = 1; /* number of processes requested */
20
21			int inpfmt = 'a'; /* input format */
22			int outfmt = 'f'; /* output format */
23
24			int report_intvl = 0; /* reporting interval (seconds) */
25
26			RcontribSimulManager myRCmanager; // global rcontrib simulation manager
27
28			#define RCONTRIB_FEATURES "Multiprocessing\n" \
29			"Accumulation\nRecovery\n" \
30			"ImmediateIrradiance\n" \
31	greg	2.2	"ProgressReporting\nDistanceLimiting\n" \
32	greg	2.1	"InputFormats=a,f,d\nOutputFormats=f,d,c\n" \
33			"Outputs=V,W\n" \
34			"OutputCS=RGB,spec\n"
35
36			static void rxcontrib(const int rstart = 0);
37
38			static void
39			printdefaults(void) /* print default values to stdout */
40			{
41			printf("-c %-5d\t\t\t# accumulated rays per record\n", myRCmanager.accum);
42	greg	2.6	printf(myRCmanager.HasFlag(RCcontrib) ?
43	greg	2.7	"-V+\t\t\t\t# output contributions\n" :
44			"-V-\t\t\t\t# output coefficients\n");
45	greg	2.2	if (myRCmanager.HasFlag(RTimmIrrad))
46	greg	2.1	printf("-I+\t\t\t\t# immediate irradiance on\n");
47			printf("-n %-2d\t\t\t\t# number of rendering processes\n", nproc);
48	greg	2.14	printf("-x %-9d\t\t\t# x resolution\n", myRCmanager.xres);
49	greg	2.6	printf("-y %-9d\t\t\t# y resolution\n", myRCmanager.yres);
50	greg	2.2	printf(myRCmanager.HasFlag(RTlimDist) ?
51			"-ld+\t\t\t\t# limit distance on\n" :
52	greg	2.1	"-ld-\t\t\t\t# limit distance off\n");
53			printf("-f%c%c\t\t\t\t# format input/output = %s/%s\n",
54			inpfmt, outfmt, formstr(inpfmt), formstr(outfmt));
55			if (report_intvl > 0)
56	greg	2.13	printf("-t %-9d\t\t\t# time between reports\n", report_intvl);
57	greg	2.1	printf(erract[WARNING].pf != NULL ?
58			"-w+\t\t\t\t# warning messages on\n" :
59			"-w-\t\t\t\t# warning messages off\n");
60			print_rdefaults();
61			}
62
63
64			static void
65			onsig( /* fatal signal */
66			int signo
67			)
68			{
69			static int gotsig = 0;
70
71			if (gotsig++) /* two signals and we're gone! */
72			_exit(signo);
73
74			#ifdef SIGALRM
75	greg	2.14	alarm(600); /* allow 10 minutes to clean up */
76	greg	2.1	signal(SIGALRM, SIG_DFL); /* make certain we do die */
77			#endif
78			eputs("signal - ");
79			eputs(sigerr[signo]);
80			eputs("\n");
81			quit(3);
82			}
83
84
85			static void
86			sigdie( /* set fatal signal */
87			int signo,
88			const char *msg
89			)
90			{
91			if (signal(signo, onsig) == SIG_IGN)
92			signal(signo, SIG_IGN);
93			sigerr[signo] = msg;
94			}
95
96			/* set input/output format */
97			static void
98			setformat(const char *fmt)
99			{
100			switch (fmt[0]) {
101			case 'f':
102			case 'd':
103			SET_FILE_BINARY(stdin);
104			/* fall through */
105			case 'a':
106			inpfmt = fmt[0];
107			break;
108			default:
109			goto fmterr;
110			}
111			switch (fmt[1]) {
112			case '\0':
113			if (inpfmt == 'a')
114			goto fmterr;
115			outfmt = inpfmt;
116			return;
117			case 'f':
118			case 'd':
119			case 'c':
120			outfmt = fmt[1];
121			break;
122			default:
123			goto fmterr;
124			}
125			if (!fmt[2])
126			return;
127			fmterr:
128			sprintf(errmsg, "Unsupported i/o format: -f%s", fmt);
129			error(USER, errmsg);
130			}
131
132	greg	2.10	/* Set default options */
133			static void
134			default_options(void)
135			{
136			rand_samp = 1;
137			dstrsrc = 0.9;
138			directrelay = 3;
139			vspretest = 512;
140			srcsizerat = .2;
141			specthresh = .02;
142			specjitter = 1.;
143			maxdepth = -10;
144			minweight = 2e-3;
145			ambres = 256;
146			ambdiv = 350;
147			ambounce = 1;
148			}
149	greg	2.1
150			/* Set overriding options */
151			static void
152			override_options(void)
153			{
154			shadthresh = 0;
155			ambssamp = 0;
156			ambacc = 0;
157			}
158
159			int
160			main(int argc, char *argv[])
161			{
162			#define check(ol,al) if (argv[i][ol] \|\| \
163			badarg(argc-i-1,argv+i+1,al)) \
164			goto badopt
165			#define check_bool(olen,var) switch (argv[i][olen]) { \
166			case '\0': var = !var; break; \
167			case 'y': case 'Y': case 't': case 'T': \
168			case '+': case '1': var = 1; break; \
169			case 'n': case 'N': case 'f': case 'F': \
170			case '-': case '0': var = 0; break; \
171			default: goto badopt; }
172			int force_open = 0;
173			int recover = 0;
174			char *curout = NULL;
175			char *prms = NULL;
176			char *binval = NULL;
177			int bincnt = 0;
178			int rval;
179			int i;
180			/* global program name */
181			progname = argv[0];
182			/* feature check only? */
183			strcat(RFeatureList, RCONTRIB_FEATURES);
184			if (argc > 1 && !strcmp(argv[1], "-features"))
185			return feature_status(argc-2, argv+2);
186			/* initialize calcomp routines early */
187			initfunc();
188			calcontext(RCCONTEXT);
189	greg	2.10	/* set rcontrib defaults */
190			default_options();
191	greg	2.1	/* option city */
192			for (i = 1; i < argc; i++) {
193			/* expand arguments */
194			while ((rval = expandarg(&argc, &argv, i)) > 0)
195			;
196			if (rval < 0) {
197			sprintf(errmsg, "cannot expand '%s'", argv[i]);
198			error(SYSTEM, errmsg);
199			}
200			if (argv[i] == NULL \|\| argv[i][0] != '-')
201			break; /* break from options */
202			if (!strcmp(argv[i], "-version")) {
203			puts(VersionID);
204			quit(0);
205			}
206			if (!strcmp(argv[i], "-defaults") \|\|
207			!strcmp(argv[i], "-help")) {
208			override_options();
209			printdefaults();
210			quit(0);
211			}
212			rval = getrenderopt(argc-i, argv+i);
213			if (rval >= 0) {
214			i += rval;
215			continue;
216			}
217			switch (argv[i][1]) {
218	greg	2.2	case 'n': /* number of processes */
219	greg	2.1	check(2,"i");
220			nproc = atoi(argv[++i]);
221			if (nproc < 0 && (nproc += RadSimulManager::GetNCores()) <= 0)
222			nproc = 1;
223			break;
224	greg	2.2	case 'V': /* output contributions? */
225	greg	2.6	rval = myRCmanager.HasFlag(RCcontrib);
226			check_bool(2,rval);
227			myRCmanager.SetFlag(RCcontrib, rval);
228	greg	2.1	break;
229			case 'x': /* x resolution */
230			check(2,"i");
231	greg	2.6	myRCmanager.xres = atoi(argv[++i]);
232	greg	2.1	break;
233			case 'y': /* y resolution */
234			check(2,"i");
235	greg	2.6	myRCmanager.yres = atoi(argv[++i]);
236	greg	2.1	break;
237	greg	2.2	case 'w': /* warnings on/off */
238	greg	2.1	rval = (erract[WARNING].pf != NULL);
239			check_bool(2,rval);
240			if (rval) erract[WARNING].pf = wputs;
241			else erract[WARNING].pf = NULL;
242			break;
243			case 'l': /* limit distance */
244			if (argv[i][2] != 'd')
245			goto badopt;
246	greg	2.2	rval = myRCmanager.HasFlag(RTlimDist);
247			check_bool(3,rval);
248			myRCmanager.SetFlag(RTlimDist, rval);
249	greg	2.1	break;
250			case 'I': /* immed. irradiance */
251	greg	2.2	rval = myRCmanager.HasFlag(RTimmIrrad);
252			check_bool(2,rval);
253			myRCmanager.SetFlag(RTimmIrrad, rval);
254	greg	2.1	break;
255	greg	2.17	case 'f': /* force or format */
256	greg	2.1	if (argv[i][2] == 'o') {
257			check_bool(3,force_open);
258			break;
259			}
260			setformat(argv[i]+2);
261			myRCmanager.SetDataFormat(outfmt);
262			break;
263	greg	2.2	case 'o': /* output file */
264	greg	2.1	check(2,"s");
265			curout = argv[++i];
266			break;
267			case 'r': /* recover output */
268			check_bool(2,recover);
269			break;
270			case 'p': /* parameter setting(s) */
271			check(2,"s");
272			set_eparams(prms = argv[++i]);
273			break;
274			case 'c': /* sample count */
275			check(2,"i");
276			myRCmanager.accum = atoi(argv[++i]);
277			break;
278			case 'b': /* bin expression/count */
279			if (argv[i][2] == 'n') {
280			check(3,"s");
281			bincnt = (int)(eval(argv[++i]) + .5);
282			break;
283			}
284			check(2,"s");
285			binval = argv[++i];
286			break;
287			case 'm': /* modifier name */
288			check(2,"s");
289	greg	2.20	if (!myRCmanager.AddModifier(argv[++i], curout, prms, binval, bincnt)) {
290			sprintf(errmsg, "bad settings for modifier '%s'", argv[i]);
291			error(USER, errmsg);
292			}
293	greg	2.1	break;
294	greg	2.2	case 'M': /* file of modifier names */
295	greg	2.1	check(2,"s");
296	greg	2.20	if (!myRCmanager.AddModFile(argv[++i], curout, prms, binval, bincnt)) {
297			sprintf(errmsg, "bad settings for modifier file '%s'", argv[i]);
298			error(USER, errmsg);
299			}
300	greg	2.1	break;
301			case 't': /* reporting interval */
302			check(2,"i");
303			report_intvl = atoi(argv[++i]);
304			break;
305			default:
306			goto badopt;
307			}
308			}
309			if (i != argc-1)
310			error(USER, "expected single octree argument");
311	greg	2.2
312			override_options(); /* override some option settings */
313
314			if (!myRCmanager.GetOutput()) // check that we have work to do
315			error(USER, "missing required modifier argument");
316	greg	2.1	// get ready to rock...
317			if (setspectrsamp(CNDX, WLPART) < 0)
318			error(USER, "unsupported spectral sampling");
319			/* set up signal handling */
320			sigdie(SIGINT, "Interrupt");
321			#ifdef SIGHUP
322			sigdie(SIGHUP, "Hangup");
323			#endif
324			sigdie(SIGTERM, "Terminate");
325			#ifdef SIGPIPE
326			sigdie(SIGPIPE, "Broken pipe");
327			#endif
328			#ifdef SIGALRM
329			sigdie(SIGALRM, "Alarm clock");
330			#endif
331			#ifdef SIGXCPU
332			sigdie(SIGXCPU, "CPU limit exceeded");
333			sigdie(SIGXFSZ, "File size exceeded");
334			#endif
335			#ifdef NICE
336			nice(NICE); /* lower priority */
337			#endif
338			// load octree
339			myRCmanager.LoadOctree(argv[argc-1]);
340			// add to header
341			myRCmanager.AddHeader(argc-1, argv);
342	greg	2.16	{
343			char buf[128] = "SOFTWARE= ";
344			strcpy(buf+10, VersionID);
345			myRCmanager.AddHeader(buf);
346			}
347	greg	2.1	// prepare output files
348			if (recover)
349			myRCmanager.outOp = RCOrecover;
350			else if (force_open)
351			myRCmanager.outOp = RCOforce;
352			else
353			myRCmanager.outOp = RCOnew;
354			// rval = # rows recovered
355			rval = myRCmanager.PrepOutput();
356	greg	2.19
357			if (rval < 0) // PrepOutput() failure?
358			error(USER, "issue loading or creating output(s)");
359			// in case we recovered everything
360			if (rval >= myRCmanager.GetRowMax())
361	greg	2.1	error(WARNING, "nothing left to compute");
362	greg	2.19	else
363			rxcontrib(rval); // trace ray contributions (loop)
364	greg	2.1
365	greg	2.19	quit(0); // exit clean
366	greg	2.1
367			badopt:
368			fprintf(stderr,
369			"Usage: %s [-V][-c count][-r][-e expr][-f source][-o ospec][-p p1=V1,p2=V2][-b binv][-bn N] {-m mod \| -M file} [rtrace options] octree\n",
370			progname);
371			sprintf(errmsg, "command line error at '%s'", argv[i]);
372			error(USER, errmsg);
373			return(1); /* pro forma return */
374
375			#undef check
376			#undef check_bool
377			}
378
379
380			// skip specified number of bytes, return false if EOF
381			static bool
382			skipBytes(int n2skip)
383			{
384			while (n2skip-- > 0)
385			if (getchar() == EOF)
386			return false;
387			return true;
388			}
389
390
391			// skip specified number of whitespace-separated words, return false if EOF
392			static bool
393			skipWords(int n2skip)
394			{
395			int c;
396
397			while (n2skip-- > 0) {
398			do {
399			c = getchar();
400			} while (isspace(c));
401			do {
402			if (c == EOF) return false;
403			c = getchar();
404			} while (!isspace(c));
405			}
406			return true;
407			}
408
409
410			// read a bundle of myRCmanager.accum ray origins and directions
411			static bool
412			getRayBundle(FVECT *orig_dir = NULL)
413			{
414			int n2go = myRCmanager.accum;
415
416			switch (inpfmt) {
417	greg	2.11	case 'a': // ASCII input
418	greg	2.1	if (!orig_dir)
419			return skipWords(6*n2go);
420			while (n2go-- > 0) {
421			if (scanf(FVFORMAT, &orig_dir[0][0],
422			&orig_dir[0][1], &orig_dir[0][2]) != 3)
423			return false;
424			if (scanf(FVFORMAT, &orig_dir[1][0],
425			&orig_dir[1][1], &orig_dir[1][2]) != 3)
426			return false;
427			orig_dir += 2;
428			}
429			break;
430	greg	2.11	case 'f': // float input
431	greg	2.1	if (!orig_dir)
432			return skipBytes(6sizeof(float)n2go);
433			#ifdef SMLFLT
434			if (getbinary(orig_dir, sizeof(FVECT), 2n2go, stdin) != 2n2go)
435			return false;
436	greg	2.11	orig_dir += 2*n2go;
437	greg	2.1	#else
438			while (n2go-- > 0) {
439			float fvecs[6];
440			if (getbinary(fvecs, sizeof(fvecs), 1, stdin) != 1)
441			return false;
442			for (int i = 6; i--; )
443			orig_dir[0][i] = fvecs[i];
444			orig_dir += 2;
445			}
446			#endif
447			break;
448	greg	2.11	case 'd': // double input
449	greg	2.1	if (!orig_dir)
450			return skipBytes(6sizeof(double)n2go);
451			#ifndef SMLFLT
452			if (getbinary(orig_dir, sizeof(FVECT), 2n2go, stdin) != 2n2go)
453			return false;
454	greg	2.11	orig_dir += 2*n2go;
455	greg	2.1	#else
456			while (n2go-- > 0) {
457			double dvecs[6];
458			if (getbinary(dvecs, sizeof(dvecs), 1, stdin) != 1)
459			return false;
460			for (int i = 6; i--; )
461			orig_dir[0][i] = dvecs[i];
462			orig_dir += 2;
463			}
464			#endif
465			break;
466			default:
467			error(INTERNAL, "unsupported format in getRayBundle()");
468			return false;
469			}
470	greg	2.11	n2go = myRCmanager.accum; // normalize directions
471	greg	2.1	while (n2go-- > 0) {
472			orig_dir -= 2;
473	greg	2.11	normalize(orig_dir[1]);
474	greg	2.1	}
475			return true;
476			}
477
478
479			// Run loop to load data, report progress, etc.
480			void
481			rxcontrib(const int rstart)
482			{
483			const int totRows = myRCmanager.GetRowMax();
484			FVECT * odarr = (FVECT )emalloc(sizeof(FVECT)2*myRCmanager.accum);
485			time_t tstart, last_report;
486			int r = 0;
487
488			while (r < rstart) { // skip input rays already done
489			if (!getRayBundle())
490			goto readerr;
491			r++;
492			}
493			if (report_intvl > 0) { // set up reporting
494			if (r > 0) {
495			sprintf(errmsg, "recovered %.2f%% of total\n",
496			100.*r/totRows);
497			eputs(errmsg);
498			}
499			last_report = tstart = time(0);
500			}
501	greg	2.12	// start children as requested
502			myRCmanager.SetThreadCount(nproc);
503
504	greg	2.8	while (r < totRows) { // loop until done
505	greg	2.1	time_t tnow;
506			if (!getRayBundle(odarr))
507			goto readerr;
508	greg	2.5	if (myRCmanager.ComputeRecord(odarr) <= 0)
509	greg	2.1	return; // error reported, hopefully...
510			r++;
511			if (report_intvl <= 0)
512			continue;
513	greg	2.13	if (r == totRows) // need to finish up?
514	greg	2.12	myRCmanager.SetThreadCount(1);
515	greg	2.13	tnow = time(0);
516			if ((r < totRows) & (tnow < last_report+report_intvl))
517	greg	2.1	continue;
518			sprintf(errmsg, "%.2f%% done after %.3f hours\n",
519	greg	2.8	100.*myRCmanager.GetRowFinished()/totRows,
520			(1./3600.)*(tnow - tstart));
521	greg	2.1	eputs(errmsg);
522			last_report = tnow;
523			}
524			efree(odarr);
525			return;
526			readerr:
527			sprintf(errmsg, "unexpected EOF on standard input (record %d of %d)",
528			r, totRows);
529			error(USER, errmsg);
530			}
531
532
533			void
534			wputs( /* warning output function */
535			const char *s
536			)
537			{
538	greg	2.3	if (!erract[WARNING].pf) return;
539	greg	2.1	int lasterrno = errno;
540			eputs(s);
541			errno = lasterrno;
542			}
543
544
545			void
546			eputs( /* put string to stderr */
547			const char *s
548			)
549			{
550			static int midline = 0;
551
552			if (!*s)
553			return;
554			if (!midline++) {
555			fputs(progname, stderr);
556			fputs(": ", stderr);
557			}
558			fputs(s, stderr);
559			if (s[strlen(s)-1] == '\n') {
560			fflush(stderr);
561			midline = 0;
562			}
563			}
564
565
566	greg	2.2	/* Exit program */
567	greg	2.1	void
568			quit(
569			int code
570			)
571			{
572	greg	2.15	myRCmanager.FlushQueue(); // leave nothing in queue
573	greg	2.1
574			exit(code);
575			}