[ViewVC] Diff of: radiance/src/util/rfluxmtx.c

Comparing src/util/rfluxmtx.c (file contents):
Revision 2.10 by greg, Fri Jul 25 17:03:06 2014 UTC vs.
Revision 2.55 by greg, Wed Nov 15 18:02:53 2023 UTC

#	Line 11 \| Line 11 \| static const char RCSid[] = "$Id$";
11		#include <stdlib.h>
12		#include "rtio.h"
13		#include "rtmath.h"
14	+	#include "rtprocess.h"
15		#include "bsdf.h"
16		#include "bsdf_m.h"
17		#include "random.h"
18		#include "triangulate.h"
19		#include "platform.h"
20
21	<	#ifdef getc_unlocked /* avoid horrendous overhead of flockfile */
22	<	#undef getc
22	<	#define getc getc_unlocked
21	>	#ifndef MAXRCARG
22	>	#define MAXRCARG 10000
23		#endif
24
25	–	#ifdef _WIN32
26	–	#define SPECIALS " \t\"$*?"
27	–	#define QUOTCHAR '"'
28	–	#else
29	–	#define SPECIALS " \t\n'\"()${}*?[];\|&"
30	–	#define QUOTCHAR '\''
31	–	#define ALTQUOT '"'
32	–	#endif
33	–
34	–	#define MAXRCARG 512
35	–
25		char progname; / global argv[0] */
26
27	<	int verbose = 0; /* verbose mode? */
27	>	int verbose = 0; /* verbose mode (< 0 no warnings) */
28
29		char *rcarg[MAXRCARG+1] = {"rcontrib", "-fo+"};
30		int nrcargs = 2;
#	Line 77 \| Line 66 \| typedef struct {
66		FVECT uva[2]; /* tangent axes */
67		int ntris; /* number of triangles */
68		struct ptri {
69	<	float afrac; /* fraction of total area */
69	>	double afrac; /* fraction of total area */
70		short vndx[3]; /* vertex indices */
71		} tri[1]; /* triangle array (extends struct) */
72		} POLYTRIS; /* triangulated polygon */
73
74		typedef struct param_s {
75	<	char hemis[32]; /* hemispherical sampling spec. */
75	>	char sign; /* '-' for axis reversal */
76	>	char hemis[31]; /* hemispherical sampling spec. */
77		int hsiz; /* hemisphere basis size */
78		int nsurfs; /* number of surfaces */
79		SURF slist; / list of surfaces */
80		FVECT vup; /* up vector (zero if unset) */
81		FVECT nrm; /* average normal direction */
82	<	FVECT udir, vdir; /* v-up tangent axes */
82	>	FVECT udir, vdir; /* tangent axes */
83		char outfn; / output file name (receiver) */
84		int (sample_basis)(struct param_s p, int, FILE *);
85		} PARAMS; /* sender/receiver parameters */
#	Line 144 \| Line 134 \| *surf_type(const char otype)**
134		static char *
135		oconv_command(int ac, char *av[])
136		{
137	<	static char oconvbuf[2048] = "!oconv -f";
138	<	char *cp = oconvbuf + 9;
139	<
140	<	while (ac-- > 0) {
141	<	if (cp >= oconvbuf+(sizeof(oconvbuf)-32)) {
142	<	fputs(progname, stderr);
143	<	fputs(": too many file arguments!\n", stderr);
144	<	exit(1);
145	<	}
156	<	*cp++ = ' ';
157	<	strcpy(cp, *av++);
158	<	while (*cp) cp++;
137	>	static char oconvbuf[2048] = "!oconv -f ";
138	>	char *cp = oconvbuf + 10;
139	>	char recv = av++;
140	>
141	>	if (ac-- <= 0)
142	>	return(NULL);
143	>	if (verbose < 0) { /* turn off warnings */
144	>	strcpy(cp, "-w ");
145	>	cp += 3;
146		}
147	<	*cp = '\0';
148	<	return(oconvbuf);
149	<	}
150	<
151	<	/* Check if any of the characters in str2 are found in str1 */
152	<	static int
153	<	matchany(const char str1, const char str2)
154	<	{
155	<	while (*str1) {
169	<	const char *cp = str2;
170	<	while (*cp)
171	<	if (cp++ == str1)
172	<	return(*str1);
173	<	++str1;
174	<	}
175	<	return(0);
176	<	}
177	<
178	<
179	<	/* Convert a set of arguments into a command line for pipe() or system() */
180	<	static char *
181	<	convert_commandline(char cmd, const int len, char av[])
182	<	{
183	<	int match;
184	<	char *cp;
185	<
186	<	for (cp = cmd; *av != NULL; av++) {
187	<	const int n = strlen(*av);
188	<	if (cp+n >= cmd+(len-3)) {
189	<	fputs(progname, stderr);
190	<	return(NULL);
191	<	}
192	<	if ((match = matchany(*av, SPECIALS))) {
193	<	const int quote =
194	<	#ifdef ALTQUOT
195	<	(match == QUOTCHAR) ? ALTQUOT :
196	<	#endif
197	<	QUOTCHAR;
198	<	*cp++ = quote;
199	<	strcpy(cp, *av);
200	<	cp += n;
201	<	*cp++ = quote;
147	>	while (ac-- > 0) { /* copy each argument */
148	>	int len = strlen(*av);
149	>	if (cp+len+4 >= oconvbuf+sizeof(oconvbuf))
150	>	goto overrun;
151	>	if (matchany(*av, SPECIALS)) {
152	>	*cp++ = QUOTCHAR;
153	>	strcpy(cp, *av++);
154	>	cp += len;
155	>	*cp++ = QUOTCHAR;
156		} else {
157	<	strcpy(cp, *av);
158	<	cp += n;
157	>	strcpy(cp, *av++);
158	>	cp += len;
159		}
160		*cp++ = ' ';
161		}
162	<	if (cp <= cmd)
163	<	return(NULL);
164	<	*--cp = '\0';
165	<	return(cmd);
162	>	/* receiver goes last */
163	>	if (matchany(recv, SPECIALS)) {
164	>	*cp++ = QUOTCHAR;
165	>	while (*recv) {
166	>	if (cp >= oconvbuf+(sizeof(oconvbuf)-3))
167	>	goto overrun;
168	>	cp++ = recv++;
169	>	}
170	>	*cp++ = QUOTCHAR;
171	>	*cp = '\0';
172	>	} else
173	>	strcpy(cp, recv);
174	>	return(oconvbuf);
175	>	overrun:
176	>	fputs(progname, stderr);
177	>	fputs(": too many file arguments!\n", stderr);
178	>	exit(1);
179		}
180
181	+	#if defined(_WIN32) \|\| defined(_WIN64)
182	+
183		/* Open a pipe to/from a command given as an argument list */
184		static FILE *
185		popen_arglist(char av[], char mode)
#	Line 222 \| Line 191 \| *popen_arglist(char av[], char mode)*
191		fputs(": command line too long in popen_arglist()\n", stderr);
192		return(NULL);
193		}
194	<	if (verbose)
194	>	if (verbose > 0)
195		fprintf(stderr, "%s: opening pipe %s: %s\n",
196		progname, (*mode=='w') ? "to" : "from", cmd);
197		return(popen(cmd, mode));
198		}
199
200	<	#ifdef _WIN32
200	>	#define pclose_al pclose
201	>
202		/* Execute system command (Windows version) */
203		static int
204		my_exec(char *av[])
#	Line 240 \| Line 210 \| *my_exec(char av[])**
210		fputs(": command line too long in my_exec()\n", stderr);
211		return(1);
212		}
213	<	if (verbose)
213	>	if (verbose > 0)
214		fprintf(stderr, "%s: running: %s\n", progname, cmd);
215		return(system(cmd));
216		}
217	<	#else
217	>
218	>	#else /* UNIX */
219	>
220	>	static SUBPROC rt_proc = SP_INACTIVE; /* we only support one of these */
221	>
222	>	/* Open a pipe to a command using an argument list */
223	>	static FILE *
224	>	popen_arglist(char av[], char mode)
225	>	{
226	>	int fd;
227	>
228	>	if (rt_proc.pid > 0) {
229	>	fprintf(stderr, "%s: only one i/o pipe at a time!\n", progname);
230	>	return(NULL);
231	>	}
232	>	if (verbose > 0) {
233	>	char cmd[4096];
234	>	if (!convert_commandline(cmd, sizeof(cmd), av))
235	>	strcpy(cmd, "COMMAND TOO LONG TO SHOW");
236	>	fprintf(stderr, "%s: opening pipe %s: %s\n",
237	>	progname, (*mode=='w') ? "to" : "from", cmd);
238	>	}
239	>	if (*mode == 'w') {
240	>	fd = rt_proc.w = dup(fileno(stdout));
241	>	rt_proc.flags \|= PF_FILT_OUT;
242	>	} else if (*mode == 'r') {
243	>	fd = rt_proc.r = dup(fileno(stdin));
244	>	rt_proc.flags \|= PF_FILT_INP;
245	>	}
246	>	if (fd < 0 \|\| open_process(&rt_proc, av) <= 0) {
247	>	perror(av[0]);
248	>	return(NULL);
249	>	}
250	>	return(fdopen(fd, mode));
251	>	}
252	>
253	>	/* Close command pipe (returns -1 on error to match pclose) */
254	>	static int
255	>	pclose_al(FILE *fp)
256	>	{
257	>	int prob = (fclose(fp) == EOF);
258	>
259	>	if (rt_proc.pid <= 0)
260	>	return(-1);
261	>
262	>	prob \|= (close_process(&rt_proc) != 0);
263	>
264	>	return(-prob);
265	>	}
266	>
267		/* Execute system command in our stead (Unix version) */
268		static int
269		my_exec(char *av[])
#	Line 255 \| Line 274 \| *my_exec(char av[])**
274		fprintf(stderr, "%s: cannot locate %s\n", progname, av[0]);
275		return(1);
276		}
277	<	if (verbose) {
277	>	if (verbose > 0) {
278		char cmd[4096];
279		if (!convert_commandline(cmd, sizeof(cmd), av))
280		strcpy(cmd, "COMMAND TOO LONG TO SHOW");
#	Line 265 \| Line 284 \| *my_exec(char av[])**
284		perror(compath);
285		return(1);
286		}
287	+
288		#endif
289
290		/* Get normalized direction vector from string specification */
#	Line 313 \| Line 333 \| *parse_params(PARAMS p, char pargs)*
333		{
334		char *cp = pargs;
335		int nparams = 0;
336	+	int quot;
337		int i;
338
339	<	for ( ; ; )
339	>	for ( ; ; ) {
340		switch (*cp++) {
341		case 'h':
342		if (*cp++ != '=')
343		break;
344	+	if ((cp == '+') \| (cp == '-'))
345	+	p->sign = *cp++;
346	+	else
347	+	p->sign = '+';
348		p->hsiz = 0;
349		i = 0;
350		while (cp && !isspace(cp)) {
#	Line 338 \| Line 363 \| *parse_params(PARAMS p, char pargs)*
363		break;
364		if (!get_direction(p->vup, cp))
365		break;
366	+	while (cp && !isspace(cp++))
367	+	;
368		++nparams;
369		continue;
370		case 'o':
371		if (*cp++ != '=')
372		break;
373	+	quot = 0;
374	+	if ((cp == '"') \| (cp == '\''))
375	+	quot = *cp++;
376		i = 0;
377	<	while (cp && !isspace(cp++))
378	<	i++;
377	>	while (cp && (quot ? (cp != quot) : !isspace(*cp))) {
378	>	i++; cp++;
379	>	}
380		if (!i)
381		break;
382	<	*--cp = '\0';
382	>	if (!*cp) {
383	>	if (quot)
384	>	break;
385	>	cp[1] = '\0';
386	>	}
387	>	*cp = '\0';
388		p->outfn = savqstr(cp-i);
389	<	*cp++ = ' ';
389	>	*cp++ = quot ? quot : ' ';
390		++nparams;
391		continue;
392		case ' ':
#	Line 363 \| Line 399 \| *parse_params(PARAMS p, char pargs)*
399		default:
400		break;
401		}
402	<	fprintf(stderr, "%s: bad parameter string '%s'\n", progname, pargs);
402	>	break;
403	>	}
404	>	fprintf(stderr, "%s: bad parameter string: %s", progname, pargs);
405		exit(1);
406		return(-1); /* pro forma return */
407		}
#	Line 408 \| Line 446 \| finish_receiver(void)
446		curparams.vup[1] = 1;
447		}
448		/* determine sample type/bin */
449	<	if (tolower(curparams.hemis[0]) == 'u' \| curparams.hemis[0] == '1') {
450	<	binv = "0"; /* uniform sampling -- one bin */
449	>	if ((tolower(curparams.hemis[0]) == 'u') \| (curparams.hemis[0] == '1')) {
450	>	sprintf(sbuf, "if(-Dx%g-Dy%g-Dz*%g,0,-1)",
451	>	curparams.nrm[0], curparams.nrm[1], curparams.nrm[2]);
452	>	binv = savqstr(sbuf);
453	>	nbins = "1"; /* uniform sampling -- one bin */
454		uniform = 1;
455		} else if (tolower(curparams.hemis[0]) == 's' &&
456		tolower(curparams.hemis[1]) == 'c') {
#	Line 420 \| Line 461 \| finish_receiver(void)
461		exit(1);
462		}
463		calfn = shirchiufn; shirchiufn = NULL;
464	<	sprintf(sbuf, "SCdim=%d,rNx=%g,rNy=%g,rNz=%g,Ux=%g,Uy=%g,Uz=%g",
464	>	sprintf(sbuf, "SCdim=%d,rNx=%g,rNy=%g,rNz=%g,Ux=%g,Uy=%g,Uz=%g,RHS=%c1",
465		curparams.hsiz,
466		curparams.nrm[0], curparams.nrm[1], curparams.nrm[2],
467	<	curparams.vup[0], curparams.vup[1], curparams.vup[2]);
467	>	curparams.vup[0], curparams.vup[1], curparams.vup[2],
468	>	curparams.sign);
469		params = savqstr(sbuf);
470		binv = "scbin";
471		nbins = "SCdim*SCdim";
472		} else if ((tolower(curparams.hemis[0]) == 'r') \|
473		(tolower(curparams.hemis[0]) == 't')) {
474		calfn = reinhfn; reinhfn = NULL;
475	<	sprintf(sbuf, "MF=%d,rNx=%g,rNy=%g,rNz=%g,Ux=%g,Uy=%g,Uz=%g",
475	>	sprintf(sbuf, "MF=%d,rNx=%g,rNy=%g,rNz=%g,Ux=%g,Uy=%g,Uz=%g,RHS=%c1",
476		curparams.hsiz,
477		curparams.nrm[0], curparams.nrm[1], curparams.nrm[2],
478	<	curparams.vup[0], curparams.vup[1], curparams.vup[2]);
478	>	curparams.vup[0], curparams.vup[1], curparams.vup[2],
479	>	curparams.sign);
480		params = savqstr(sbuf);
481		binv = "rbin";
482		nbins = "Nrbins";
#	Line 461 \| Line 504 \| finish_receiver(void)
504		progname, curparams.hemis);
505		exit(1);
506		}
507	+	if (tolower(curparams.hemis[0]) == 'k') {
508	+	sprintf(sbuf, "RHS=%c1", curparams.sign);
509	+	params = savqstr(sbuf);
510	+	}
511		if (!uniform & (curparams.slist->styp == ST_SOURCE)) {
512		SURF *sp;
513		for (sp = curparams.slist; sp != NULL; sp = sp->next)
#	Line 508 \| Line 555 \| make_axes(FVECT uva[2], const FVECT nrm)
555		{
556		int i;
557
558	<	uva[1][0] = 0.5 - frandom();
512	<	uva[1][1] = 0.5 - frandom();
513	<	uva[1][2] = 0.5 - frandom();
514	<	for (i = 3; i--; )
515	<	if ((-0.6 < nrm[i]) & (nrm[i] < 0.6))
516	<	break;
517	<	if (i < 0) {
558	>	if (!getperpendicular(uva[0], nrm, 1)) {
559		fputs(progname, stderr);
560		fputs(": bad surface normal in make_axes!\n", stderr);
561		exit(1);
562		}
563	<	uva[1][i] = 1.0;
523	<	VCROSS(uva[0], uva[1], nrm);
524	<	normalize(uva[0]);
525	<	VCROSS(uva[1], nrm, uva[0]);
563	>	fcross(uva[1], nrm, uva[0]);
564		}
565
566		/* Illegal sender surfaces end up here */
#	Line 631 \| Line 669 \| *ssamp_poly(FVECT orig, SURF sp, double x)**
669		sp->priv = (void *)ptp;
670		}
671		/* pick triangle by partial area */
672	<	for (i = 0; i < ptp->ntris && x > ptp->tri[i].afrac; i++)
672	>	for (i = 0; i < ptp->ntris-1 && x > ptp->tri[i].afrac; i++)
673		x -= ptp->tri[i].afrac;
674		SDmultiSamp(samp2, 2, x/ptp->tri[i].afrac);
675		samp2[0] *= samp2[1] = sqrt(samp2[1]);
#	Line 661 \| Line 699 \| *sample_origin(PARAMS p, FVECT orig, const FVECT rdir,**
699		/* special case for lone surface */
700		if (p->nsurfs == 1) {
701		sp = p->slist;
702	<	if (DOT(sp->snrm, rdir) >= -FTINY) {
702	>	if (DOT(sp->snrm, rdir) >= FTINY) {
703		fprintf(stderr,
704		"%s: internal - sample behind sender '%s'\n",
705		progname, sp->sname);
#	Line 672 \| Line 710 \| *sample_origin(PARAMS p, FVECT orig, const FVECT rdir,**
710		if (p->nsurfs > nall) { /* (re)allocate surface area cache */
711		if (projsa) free(projsa);
712		projsa = (double )malloc(sizeof(double)p->nsurfs);
713	<	if (!projsa) return(0);
713	>	if (projsa == NULL) {
714	>	fputs(progname, stderr);
715	>	fputs(": out of memory in sample_origin!\n", stderr);
716	>	exit(1);
717	>	}
718		nall = p->nsurfs;
719		}
720		/* compute projected areas */
721		for (i = 0, sp = p->slist; sp != NULL; i++, sp = sp->next) {
722		projsa[i] = -DOT(sp->snrm, rdir) * sp->area;
723	<	tarea += projsa[i] *= (double)(projsa[i] > FTINY);
723	>	tarea += projsa[i] *= (double)(projsa[i] > 0);
724		}
725	<	if (tarea <= FTINY) { /* wrong side of sender? */
725	>	if (tarea < FTINYFTINY) { / wrong side of sender? */
726		fputs(progname, stderr);
727		fputs(": internal - sample behind all sender elements!\n",
728		stderr);
#	Line 698 \| Line 740 \| *sample_uniform(PARAMS p, int b, FILE fp)*
740		{
741		int n = sampcnt;
742		double samp3[3];
743	<	double duvw[3];
702	<	FVECT orig_dir[2];
743	>	FVECT duvw, orig_dir[2];
744		int i;
745
746		if (fp == NULL) /* just requesting number of bins? */
#	Line 707 \| Line 748 \| *sample_uniform(PARAMS p, int b, FILE fp)*
748
749		while (n--) { /* stratified hemisphere sampling */
750		SDmultiSamp(samp3, 3, (n+frandom())/sampcnt);
751	<	SDsquare2disk(duvw, samp3[1], samp3[2]);
751	>	square2disk(duvw, samp3[1], samp3[2]);
752		duvw[2] = -sqrt(1. - duvw[0]duvw[0] - duvw[1]duvw[1]);
753		for (i = 3; i--; )
754		orig_dir[1][i] = duvw[0]*p->udir[i] +
#	Line 715 \| Line 756 \| *sample_uniform(PARAMS p, int b, FILE fp)*
756		duvw[2]*p->nrm[i] ;
757		if (!sample_origin(p, orig_dir[0], orig_dir[1], samp3[0]))
758		return(0);
759	<	if (fwrite(orig_dir, sizeof(FVECT), 2, fp) != 2)
759	>	if (putbinary(orig_dir, sizeof(FVECT), 2, fp) != 2)
760		return(0);
761		}
762		return(1);
#	Line 727 \| Line 768 \| *sample_shirchiu(PARAMS p, int b, FILE fp)*
768		{
769		int n = sampcnt;
770		double samp3[3];
771	<	double duvw[3];
731	<	FVECT orig_dir[2];
771	>	FVECT duvw, orig_dir[2];
772		int i;
773
774		if (fp == NULL) /* just requesting number of bins? */
#	Line 736 \| Line 776 \| *sample_shirchiu(PARAMS p, int b, FILE fp)*
776
777		while (n--) { /* stratified sampling */
778		SDmultiSamp(samp3, 3, (n+frandom())/sampcnt);
779	<	SDsquare2disk(duvw, (b/p->hsiz + samp3[1])/curparams.hsiz,
779	>	square2disk(duvw, (b/p->hsiz + samp3[1])/curparams.hsiz,
780		(b%p->hsiz + samp3[2])/curparams.hsiz);
781		duvw[2] = sqrt(1. - duvw[0]duvw[0] - duvw[1]duvw[1]);
782		for (i = 3; i--; )
#	Line 745 \| Line 785 \| *sample_shirchiu(PARAMS p, int b, FILE fp)*
785		duvw[2]*p->nrm[i] ;
786		if (!sample_origin(p, orig_dir[0], orig_dir[1], samp3[0]))
787		return(0);
788	<	if (fwrite(orig_dir, sizeof(FVECT), 2, fp) != 2)
788	>	if (putbinary(orig_dir, sizeof(FVECT), 2, fp) != 2)
789		return(0);
790		}
791		return(1);
#	Line 781 \| Line 821 \| *sample_reinhart(PARAMS p, int b, FILE fp)*
821		}
822		while (n--) { /* stratified sampling */
823		SDmultiSamp(samp3, 3, (n+frandom())/sampcnt);
824	+	if (row >= RowMax-1) /* avoid crowding at zenith */
825	+	samp3[1] *= samp3[1];
826		alt = (row+samp3[1])*RAH;
827		azi = (2.PI)(col+samp3[2]-.5)/rnaz(row);
828		duvw[2] = cos(alt); /* measured from horizon */
829	<	duvw[0] = tcos(azi)*duvw[2];
830	<	duvw[1] = tsin(azi)*duvw[2];
829	>	duvw[0] = tsin(azi)*duvw[2];
830	>	duvw[1] = -tcos(azi)*duvw[2];
831		duvw[2] = sqrt(1. - duvw[2]*duvw[2]);
832		for (i = 3; i--; )
833		orig_dir[1][i] = -duvw[0]*p->udir[i] -
#	Line 793 \| Line 835 \| *sample_reinhart(PARAMS p, int b, FILE fp)*
835		duvw[2]*p->nrm[i] ;
836		if (!sample_origin(p, orig_dir[0], orig_dir[1], samp3[0]))
837		return(0);
838	<	if (fwrite(orig_dir, sizeof(FVECT), 2, fp) != 2)
838	>	if (putbinary(orig_dir, sizeof(FVECT), 2, fp) != 2)
839		return(0);
840		}
841		return(1);
#	Line 836 \| Line 878 \| *sample_klems(PARAMS p, int b, FILE fp)*
878
879		while (n--) { /* stratified sampling */
880		SDmultiSamp(samp2, 2, (n+frandom())/sampcnt);
881	<	if (!bo_getvec(duvw, b+samp2[1], kbasis[bi]))
881	>	if (!fo_getvec(duvw, b+samp2[1], kbasis[bi]))
882		return(0);
883		for (i = 3; i--; )
884	<	orig_dir[1][i] = duvw[0]*p->udir[i] +
885	<	duvw[1]*p->vdir[i] +
884	>	orig_dir[1][i] = -duvw[0]*p->udir[i] -
885	>	duvw[1]*p->vdir[i] -
886		duvw[2]*p->nrm[i] ;
887		if (!sample_origin(p, orig_dir[0], orig_dir[1], samp2[0]))
888		return(0);
889	<	if (fwrite(orig_dir, sizeof(FVECT), 2, fp) != 2)
889	>	if (putbinary(orig_dir, sizeof(FVECT), 2, fp) != 2)
890		return(0);
891		}
892		return(1);
#	Line 859 \| Line 901 \| prepare_sampler(void)
901		fputs(": no sender surface!\n", stderr);
902		return(-1);
903		}
904	<	if (curparams.outfn != NULL) /* misplaced output file spec. */
904	>	/* misplaced output file spec. */
905	>	if ((curparams.outfn != NULL) & (verbose >= 0))
906		fprintf(stderr, "%s: warning - ignoring output file in sender ('%s')\n",
907		progname, curparams.outfn);
908		/* check/set basis hemisphere */
#	Line 879 \| Line 922 \| prepare_sampler(void)
922		else
923		curparams.vup[1] = 1;
924		}
925	<	VCROSS(curparams.udir, curparams.vup, curparams.nrm);
925	>	fcross(curparams.udir, curparams.vup, curparams.nrm);
926		if (normalize(curparams.udir) == 0) {
927		fputs(progname, stderr);
928		fputs(": up vector coincides with sender normal\n", stderr);
929		return(-1);
930		}
931	<	VCROSS(curparams.vdir, curparams.nrm, curparams.udir);
932	<	if (tolower(curparams.hemis[0]) == 'u' \| curparams.hemis[0] == '1')
931	>	fcross(curparams.vdir, curparams.nrm, curparams.udir);
932	>	if (curparams.sign == '-') { /* left-handed coordinate system? */
933	>	curparams.udir[0] *= -1.;
934	>	curparams.udir[1] *= -1.;
935	>	curparams.udir[2] *= -1.;
936	>	}
937	>	if ((tolower(curparams.hemis[0]) == 'u') \| (curparams.hemis[0] == '1'))
938		curparams.sample_basis = sample_uniform;
939		else if (tolower(curparams.hemis[0]) == 's' &&
940		tolower(curparams.hemis[1]) == 'c')
#	Line 947 \| Line 995 \| *finish_polygon(SURF p)**
995		VCOPY(e1, e2);
996		}
997		p->area = normalize(p->snrm)*0.5;
998	<	return(p->area > FTINY);
998	>	return(p->area > FTINY*FTINY);
999		}
1000
1001		/* Add a surface to our current parameters */
#	Line 965 \| Line 1013 \| *add_surface(int st, const char oname, FILE fp)*
1013		snew = (SURF )malloc(sizeof(SURF) + sizeof(double)(n-1));
1014		if (snew == NULL) {
1015		fputs(progname, stderr);
1016	<	fputs(": out of memory!\n", stderr);
1016	>	fputs(": out of memory in add_surface!\n", stderr);
1017		exit(1);
1018		}
1019		strncpy(snew->sname, oname, sizeof(snew->sname)-1);
#	Line 1010 \| Line 1058 \| *add_surface(int st, const char oname, FILE fp)*
1058		snew->area = PIsnew->area;
1059		break;
1060		}
1061	<	if (snew->area <= FTINY) {
1061	>	if ((snew->area <= FTINY*FTINY) & (verbose >= 0)) {
1062		fprintf(stderr, "%s: warning - zero area for surface '%s'\n",
1063		progname, oname);
1064		free(snew);
#	Line 1080 \| Line 1128 \| static int
1128		add_send_object(FILE *fp)
1129		{
1130		int st;
1131	<	char otype[32], oname[128];
1131	>	char thismod[128], otype[32], oname[128];
1132		int n;
1133
1134	<	if (fscanf(fp, "%*s %s %s", otype, oname) != 2)
1134	>	if (fscanf(fp, "%s %s %s", thismod, otype, oname) != 3)
1135		return(0); /* must have hit EOF! */
1136		if (!strcmp(otype, "alias")) {
1137		fscanf(fp, "%s"); / skip alias */
#	Line 1096 \| Line 1144 \| *add_send_object(FILE fp)**
1144		fputs(": cannot use source as a sender!\n", stderr);
1145		return(-1);
1146		}
1147	+	if (strcmp(thismod, curmod)) {
1148	+	if (curmod[0]) {
1149	+	fputs(progname, stderr);
1150	+	fputs(": warning - multiple modifiers in sender\n",
1151	+	stderr);
1152	+	}
1153	+	strcpy(curmod, thismod);
1154	+	}
1155		parse_params(&curparams, newparams);
1156		newparams[0] = '\0';
1157		add_surface(st, oname, fp); /* read & store surface */
#	Line 1174 \| Line 1230 \| *main(int argc, char argv[])**
1230		{
1231		char fmtopt[6] = "-faa"; /* default output is ASCII */
1232		char xrs=NULL, yrs=NULL, *ldopt=NULL;
1233	<	int wantIrradiance = 0;
1233	>	char *iropt = NULL;
1234		char *sendfn;
1235		char sampcntbuf[32], nsbinbuf[32];
1236		FILE *rcfp;
#	Line 1182 \| Line 1238 \| *main(int argc, char argv[])**
1238		int a, i;
1239		/* screen rcontrib options */
1240		progname = argv[0];
1241	<	for (a = 1; a < argc-2 && argv[a][0] == '-'; a++) {
1242	<	int na = 1; /* !! Keep consistent !! */
1243	<	switch (argv[a][1]) {
1241	>	for (a = 1; a < argc-2; a++) {
1242	>	int na;
1243	>	/* check for argument expansion */
1244	>	while ((na = expandarg(&argc, &argv, a)) > 0)
1245	>	;
1246	>	if (na < 0) {
1247	>	fprintf(stderr, "%s: cannot expand '%s'\n",
1248	>	progname, argv[a]);
1249	>	return(1);
1250	>	}
1251	>	if (argv[a][0] != '-' \|\| !argv[a][1])
1252	>	break;
1253	>	na = 1;
1254	>	switch (argv[a][1]) { /* !! Keep consistent !! */
1255		case 'v': /* verbose mode */
1256	<	verbose = !verbose;
1256	>	verbose = 1;
1257		na = 0;
1258		continue;
1259		case 'f': /* special case for -fo, -ff, etc. */
#	Line 1216 \| Line 1283 \| *main(int argc, char argv[])**
1283		yrs = argv[++a];
1284		na = 0;
1285		continue;
1286	<	case 'c': /* number of samples */
1287	<	sampcnt = atoi(argv[++a]);
1288	<	if (sampcnt <= 0)
1289	<	goto userr;
1290	<	na = 0; /* we re-add this later */
1286	>	case 'c': /* spectral sampling or count */
1287	>	switch (argv[a][2]) {
1288	>	case 's':
1289	>	na = 2;
1290	>	break;
1291	>	case 'w':
1292	>	na = 3;
1293	>	break;
1294	>	case '\0':
1295	>	sampcnt = atoi(argv[++a]);
1296	>	if (sampcnt <= 0)
1297	>	goto userr;
1298	>	na = 0; /* we re-add this later */
1299	>	break;
1300	>	}
1301		continue;
1302		case 'I': /* only for pass-through mode */
1303	<	wantIrradiance = 1;
1303	>	case 'i':
1304	>	iropt = argv[a];
1305		na = 0;
1306		continue;
1307	<	case 'V': /* options without arguments */
1308	<	case 'w':
1307	>	case 'w': /* options without arguments */
1308	>	if (!argv[a][2] \|\| strchr("+1tTyY", argv[a][2]) == NULL)
1309	>	verbose = -1;
1310	>	break;
1311	>	case 'V':
1312		case 'u':
1232	–	case 'i':
1313		case 'h':
1314		case 'r':
1315		break;
1316		case 'n': /* options with 1 argument */
1317		case 's':
1318		case 'o':
1319	+	case 't':
1320		na = 2;
1321		break;
1322		case 'b': /* special case */
#	Line 1253 \| Line 1334 \| *main(int argc, char argv[])**
1334		if (argv[a][2] != 'v') na = 2;
1335		break;
1336		case 'a': /* special case */
1337	<	na = (argv[a][2] == 'v') ? 4 : 2;
1337	>	if (argv[a][2] == 'p') {
1338	>	na = 2; /* photon map [+ bandwidth(s)] */
1339	>	if (a < argc-3 && atoi(argv[a+1]) > 0)
1340	>	na += 1 + (a < argc-4 && atoi(argv[a+2]) > 0);
1341	>	} else
1342	>	na = (argv[a][2] == 'v') ? 4 : 2;
1343		break;
1344		case 'm': /* special case */
1345		if (!argv[a][2]) goto userr;
1346		na = (argv[a][2] == 'e') \| (argv[a][2] == 'a') ? 4 : 2;
1347		break;
1262	–	case '\0': /* pass-through mode */
1263	–	goto done_opts;
1348		default: /* anything else is verbotten */
1349		goto userr;
1350		}
#	Line 1270 \| Line 1354 \| *main(int argc, char argv[])**
1354		while (--na) /* + arguments if any */
1355		rcarg[nrcargs++] = argv[++a];
1356		}
1273	–	done_opts:
1357		if (a > argc-2)
1358		goto userr; /* check at end of options */
1359		sendfn = argv[a++]; /* assign sender & receiver inputs */
1360		if (sendfn[0] == '-') { /* user wants pass-through mode? */
1361		if (sendfn[1]) goto userr;
1362		sendfn = NULL;
1363	<	if (wantIrradiance) {
1363	>	if (iropt) {
1364		CHECKARGC(1);
1365	<	rcarg[nrcargs++] = "-I";
1365	>	rcarg[nrcargs++] = iropt;
1366		}
1367		if (xrs) {
1368		CHECKARGC(2);
#	Line 1297 \| Line 1380 \| done_opts:
1380		}
1381		if (sampcnt <= 0) sampcnt = 1;
1382		} else { /* else in sampling mode */
1383	<	if (wantIrradiance) {
1383	>	if (iropt) {
1384		fputs(progname, stderr);
1385	<	fputs(": -I supported for pass-through only\n", stderr);
1385	>	fputs(": -i, -I supported for pass-through only\n", stderr);
1386		return(1);
1387		}
1388	<	fmtopt[2] = (sizeof(RREAL)==sizeof(double)) ? 'd' : 'f';
1388	>	#ifdef SMLFLT
1389	>	fmtopt[2] = 'f';
1390	>	#else
1391	>	fmtopt[2] = 'd';
1392	>	#endif
1393		if (sampcnt <= 0) sampcnt = 10000;
1394		}
1395		sprintf(sampcntbuf, "%d", sampcnt);
#	Line 1321 \| Line 1408 \| done_opts:
1408		return(my_exec(rcarg)); /* rcontrib does everything */
1409		}
1410		clear_params(&curparams, 0); /* else load sender surface & params */
1411	+	curmod[0] = '\0';
1412		if (load_scene(sendfn, add_send_object) < 0)
1413		return(1);
1414		if ((nsbins = prepare_sampler()) <= 0)
#	Line 1338 \| Line 1426 \| done_opts:
1426		#ifdef getc_unlocked
1427		flockfile(rcfp);
1428		#endif
1429	<	if (verbose) {
1429	>	if (verbose > 0) {
1430		fprintf(stderr, "%s: sampling %d directions", progname, nsbins);
1431		if (curparams.nsurfs > 1)
1432		fprintf(stderr, " (%d elements)\n", curparams.nsurfs);
#	Line 1348 \| Line 1436 \| done_opts:
1436		for (i = 0; i < nsbins; i++) /* send rcontrib ray samples */
1437		if (!(*curparams.sample_basis)(&curparams, i, rcfp))
1438		return(1);
1439	<	return(pclose(rcfp) == 0); /* all finished! */
1439	>	return(pclose_al(rcfp) < 0); /* all finished! */
1440		userr:
1441		if (a < argc-2)
1442		fprintf(stderr, "%s: unsupported option '%s'", progname, argv[a]);
1443	<	fprintf(stderr, "Usage: %s [-v][rcontrib options] sender.rad receiver.rad [system.rad ..]\n",
1443	>	fprintf(stderr, "Usage: %s [-v][rcontrib options] sender.rad receiver.rad [-i system.oct] [system.rad ..]\n",
1444		progname);
1445		return(1);
1446		}

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing src/util/rfluxmtx.c (file contents): Revision 2.10 by greg, Fri Jul 25 17:03:06 2014 UTC vs. Revision 2.55 by greg, Wed Nov 15 18:02:53 2023 UTC

Diff Legend

Comparing src/util/rfluxmtx.c (file contents):
Revision 2.10 by greg, Fri Jul 25 17:03:06 2014 UTC vs.
Revision 2.55 by greg, Wed Nov 15 18:02:53 2023 UTC