ViewVC Help

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

root/Development/ray/src/rt/mkpmap.c

Comparing ray/src/rt/mkpmap.c (file contents):
Revision 2.8 by rschregle, Fri Feb 2 19:47:55 2018 UTC vs.
Revision 2.9 by rschregle, Tue Mar 20 19:55:33 2018 UTC

#	Line 20 | Line 20 | static const char RCSid[] = "$Id$";
20
21		#include "pmap.h"
22		#include "pmapmat.h"
23	+	#include "pmapsrc.h"
24		#include "pmapcontrib.h"
25		#include "pmaprand.h"
26		#include "paths.h"
#	Line 49 | Line 50 | int      clobber = 0;               /* overwrite outpu
50		COLOR    cextinction = BLKCOLOR;    /* global extinction coefficient */
51		COLOR    salbedo = BLKCOLOR;        /* global scattering albedo */
52		double   seccg = 0;                 /* global scattering eccentricity */
53	<	int      ambincl = -1;              /* photon port flag */
54	<	char     *amblist [AMBLLEN + 1];    /* photon port list */
53	>	char     *amblist [AMBLLEN + 1];    /* ambient include/exclude list */
54	>	int      ambincl = -1;              /* include == 1, exclude == 0 */
55		char     *diagFile = NULL;          /* diagnostics output file */
56		int      rand_samp = 1;             /* uncorrelated random sampling */
57		unsigned nproc = 1;                 /* number of parallel processes */
#	Line 80 | Line 81 | void printdefaults()
81		/* EvalDRC support */
82		puts("-A\t\t\t\t# angular source file");
83		#endif
84	+	puts("-ae  mod\t\t\t\t# exclude modifier");
85	+	puts("-aE  file\t\t\t\t# exclude modifiers from file");
86	+	puts("-ai  mod\t\t\t\t# include modifier");
87	+	puts("-aI  file\t\t\t\t# include modifiers from file");
88		#ifdef PMAP_EKSPERTZ
89		puts("-api xmin ymin zmin xmax ymax zmax\t# region of interest");
90		#endif
#	Line 96 | Line 101 | void printdefaults()
101		printf("-apm %ld\t\t\t\t# limit photon bounces\n", photonMaxBounce);
102		#endif
103		puts("-apo mod\t\t\t\t# photon port modifier");
104	<	puts("-apO file\t\t\t\t# photon port file");
104	>	puts("-apO file\t\t\t\t# photon ports from file");
105		printf("-apP %f\t\t\t\t# precomputation factor\n", finalGather);
106		printf("-apr %d\t\t\t\t\t# random seed\n", randSeed);
107		puts("-aps mod\t\t\t\t# antimatter sensor modifier");
108	<	puts("-apS file\t\t\t\t# antimatter sensor file");
108	>	puts("-apS file\t\t\t\t# antimatter sensors from file");
109
110		printf(backvis ? "-bv+\t\t\t\t\t# back face visibility on\n"
111		: "-bv-\t\t\t\t\t# back face visibility off\n");
#	Line 145 | Line 150 | int main (int argc, char* argv [])
150		default: goto badopt; \
151		}
152
153	<	int loadflags = IO_CHECK | IO_SCENE | IO_TREE | IO_BOUNDS, rval, i;
154	<	char **portLp = NULL, **sensLp = photonSensorList;
153	>	int loadflags = IO_CHECK | IO_SCENE | IO_TREE | IO_BOUNDS, rval, i, j, n;
154	>	char **portLp = photonPortList, **sensLp = photonSensorList,
155	>	**amblp = NULL;
156		struct stat pmstat;
157
158		/* Global program name */
#	Line 183 | Line 189 | int main (int argc, char* argv [])
189		}
190
191		switch (argv [i][1]) {
192	<	case 'a':
193	<	if (!strcmp(argv [i] + 2, "pg")) {
194	<	/* Global photon map */
195	<	check(4, "ss");
196	<	globalPmapParams.fileName = argv [++i];
197	<	globalPmapParams.distribTarget =
198	<	parseMultiplier(argv [++i]);
199	<	if (!globalPmapParams.distribTarget)
200	<	goto badopt;
201	<	globalPmapParams.minGather = globalPmapParams.maxGather = 0;
202	<	}
192	>	case 'a': /* Ambient */
193	>	switch (argv [i][2]) {
194	>	case 'i': /* Ambient include */
195	>	case 'I':
196	>	check(3, "s");
197	>	if (ambincl != 1) {
198	>	ambincl = 1;
199	>	amblp = amblist;
200	>	}
201	>	if (argv [i][2] == 'I') {
202	>	/* Add modifiers from file */
203	>	rval = wordfile(amblp, AMBLLEN - (amblp - amblist),
204	>	getpath(argv [++i],
205	>	getrlibpath(), R_OK));
206	>	if (rval < 0) {
207	>	sprintf(errmsg,
208	>	"cannot open ambient include file \"%s\"",
209	>	argv [i]);
210	>	error(SYSTEM, errmsg);
211	>	}
212	>	amblp += rval;
213	>	}
214	>	else {
215	>	/* Add modifier from next arg */
216	>	*amblp++ = savqstr(argv [++i]);
217	>	*amblp = NULL;
218	>	}
219	>	break;
220	>
221	>	case 'e': /* Ambient exclude */
222	>	case 'E':
223	>	check(3, "s");
224	>	if (ambincl != 0) {
225	>	ambincl = 0;
226	>	amblp = amblist;
227	>	}
228	>	if (argv [i][2] == 'E') {
229	>	/* Add modifiers from file */
230	>	rval = wordfile(amblp, AMBLLEN - (amblp - amblist),
231	>	getpath(argv [++i],
232	>	getrlibpath(), R_OK));
233	>	if (rval < 0) {
234	>	sprintf(errmsg,
235	>	"cannot open ambient exclude file \"%s\"",
236	>	argv [i]);
237	>	error(SYSTEM, errmsg);
238	>	}
239	>	amblp += rval;
240	>	}
241	>	else {
242	>	/* Add modifier from next arg */
243	>	*amblp++ = savqstr(argv [++i]);
244	>	*amblp = NULL;
245	>	}
246	>	break;
247
248	<	else if (!strcmp(argv [i] + 2, "pp")) {
249	<	/* Precomputed global photon map */
250	<	check(4, "ssi");
251	<	preCompPmapParams.fileName = argv [++i];
252	<	preCompPmapParams.distribTarget =
253	<	parseMultiplier(argv [++i]);
254	<	if (!preCompPmapParams.distribTarget)
255	<	goto badopt;
256	<	preCompPmapParams.minGather = preCompPmapParams.maxGather =
257	<	atoi(argv [++i]);
258	<	if (!preCompPmapParams.maxGather)
259	<	goto badopt;
210	<	}
248	>	case 'p': /* Pmap-specific */
249	>	switch (argv [i][3]) {
250	>	case 'g': /* Global photon map */
251	>	check(4, "ss");
252	>	globalPmapParams.fileName = argv [++i];
253	>	globalPmapParams.distribTarget =
254	>	parseMultiplier(argv [++i]);
255	>	if (!globalPmapParams.distribTarget)
256	>	goto badopt;
257	>	globalPmapParams.minGather =
258	>	globalPmapParams.maxGather = 0;
259	>	break;
260
261	<	else if (!strcmp(argv [i] + 2, "pc")) {
262	<	/* Caustic photon map */
263	<	check(4, "ss");
264	<	causticPmapParams.fileName = argv [++i];
265	<	causticPmapParams.distribTarget =
266	<	parseMultiplier(argv [++i]);
267	<	if (!causticPmapParams.distribTarget)
268	<	goto badopt;
269	<	}
261	>	case 'p': /* Precomputed global photon map */
262	>	check(4, "ssi");
263	>	preCompPmapParams.fileName = argv [++i];
264	>	preCompPmapParams.distribTarget =
265	>	parseMultiplier(argv [++i]);
266	>	if (!preCompPmapParams.distribTarget)
267	>	goto badopt;
268	>	preCompPmapParams.minGather =
269	>	preCompPmapParams.maxGather = atoi(argv [++i]);
270	>	if (!preCompPmapParams.maxGather)
271	>	goto badopt;
272	>	break;
273
274	<	else if (!strcmp(argv [i] + 2, "pv")) {
275	<	/* Volume photon map */
276	<	check(4, "ss");
277	<	volumePmapParams.fileName = argv [++i];
278	<	volumePmapParams.distribTarget =
279	<	parseMultiplier(argv [++i]);
280	<	if (!volumePmapParams.distribTarget)
281	<	goto badopt;
282	<	}
283	<
284	<	else if (!strcmp(argv [i] + 2, "pd")) {
285	<	/* Direct photon map */
286	<	check(4, "ss");
287	<	directPmapParams.fileName = argv [++i];
288	<	directPmapParams.distribTarget =
289	<	parseMultiplier(argv [++i]);
290	<	if (!directPmapParams.distribTarget)
291	<	goto badopt;
292	<	}
293	<
294	<	else if (!strcmp(argv [i] + 2, "pC")) {
295	<	/* Light source contribution photon map */
296	<	check(4, "ss");
297	<	contribPmapParams.fileName = argv [++i];
298	<	contribPmapParams.distribTarget =
299	<	parseMultiplier(argv [++i]);
300	<	if (!contribPmapParams.distribTarget)
301	<	goto badopt;
302	<	}
274	>	case 'c': /* Caustic photon map */
275	>	check(4, "ss");
276	>	causticPmapParams.fileName = argv [++i];
277	>	causticPmapParams.distribTarget =
278	>	parseMultiplier(argv [++i]);
279	>	if (!causticPmapParams.distribTarget)
280	>	goto badopt;
281	>	break;
282	>
283	>	case 'v': /* Volume photon map */
284	>	check(4, "ss");
285	>	volumePmapParams.fileName = argv [++i];
286	>	volumePmapParams.distribTarget =
287	>	parseMultiplier(argv [++i]);
288	>	if (!volumePmapParams.distribTarget)
289	>	goto badopt;
290	>	break;
291	>
292	>	case 'd': /* Direct photon map */
293	>	check(4, "ss");
294	>	directPmapParams.fileName = argv [++i];
295	>	directPmapParams.distribTarget =
296	>	parseMultiplier(argv [++i]);
297	>	if (!directPmapParams.distribTarget)
298	>	goto badopt;
299	>	break;
300	>
301	>	case 'C': /* Contribution photon map */
302	>	check(4, "ss");
303	>	contribPmapParams.fileName = argv [++i];
304	>	contribPmapParams.distribTarget =
305	>	parseMultiplier(argv [++i]);
306	>	if (!contribPmapParams.distribTarget)
307	>	goto badopt;
308	>	break;
309
310	<	else if (!strcmp(argv [i] + 2, "pD")) {
311	<	/* Predistribution factor */
312	<	check(4, "f");
313	<	preDistrib = atof(argv [++i]);
314	<	if (preDistrib <= 0)
315	<	error(USER, "predistribution factor must be > 0");
258	<	}
310	>	case 'D': /* Predistribution factor */
311	>	check(4, "f");
312	>	preDistrib = atof(argv [++i]);
313	>	if (preDistrib <= 0)
314	>	error(USER, "predistrib factor must be > 0");
315	>	break;
316
317	<	else if (!strcmp(argv [i] + 2, "pM")) {
318	<	/* Max predistribution passes */
319	<	check(4, "i");
320	<	maxPreDistrib = atoi(argv [++i]);
321	<	if (maxPreDistrib <= 0)
322	<	error(USER, "max predistribution passes must be > 0");
323	<	}
317	>	case 'M': /* Max predistribution passes */
318	>	check(4, "i");
319	>	maxPreDistrib = atoi(argv [++i]);
320	>	if (maxPreDistrib <= 0)
321	>	error(USER, "max predistrib passes must be > 0");
322	>	break;
323	>
324		#if 1
325	<	/* Kept for backwards compat, to be phased out by -lr */
326	<	else if (!strcmp(argv [i] + 2, "pm")) {
327	<	/* Max photon bounces */
328	<	check(4, "i");
329	<	photonMaxBounce = atol(argv [++i]);
330	<	if (photonMaxBounce <= 0)
331	<	error(USER, "max photon bounces must be > 0");
275	<	}
325	>	/* Kept for backwards compat, to be phased out by -lr */
326	>	case 'm': /* Max photon bounces */
327	>	check(4, "i");
328	>	photonMaxBounce = atol(argv [++i]);
329	>	if (photonMaxBounce <= 0)
330	>	error(USER, "max photon bounces must be > 0");
331	>	break;
332		#endif
333	<	#ifdef PMAP_EKSPERTZ
334	<	/* Add region of interest; for Ze Ekspertz only! */
335	<	else if (!strcmp(argv [i] + 2, "pi")) {
336	<	unsigned j, n = pmapNumROI;
337	<	check(4, "ffffff");
338	<
339	<	pmapROI = realloc(pmapROI,
340	<	++pmapNumROI * sizeof(PhotonMapROI));
341	<	if (!pmapROI)
342	<	error(SYSTEM, "failed to allocate ROI");
343	<
344	<	pmapROI [n].min [0] = atof(argv [++i]);
345	<	pmapROI [n].min [1] = atof(argv [++i]);
346	<	pmapROI [n].min [2] = atof(argv [++i]);
347	<	pmapROI [n].max [0] = atof(argv [++i]);
348	<	pmapROI [n].max [1] = atof(argv [++i]);
349	<	pmapROI [n].max [2] = atof(argv [++i]);
350	<
351	<	for (j = 0; j < 3; j++)
352	<	if (pmapROI [n].min [j] >= pmapROI [n].max [j])
297	<	error(USER,
298	<	"invalid region of interest (swapped min/max?)");
299	<	}
333	>
334	>	#ifdef PMAP_EKSPERTZ
335	>	case 'i': /* Add region of interest */
336	>	check(4, "ffffff");
337	>	n = pmapNumROI;
338	>	pmapROI = realloc(pmapROI,
339	>	++pmapNumROI * sizeof(PhotonMapROI));
340	>	if (!pmapROI)
341	>	error(SYSTEM, "failed to allocate ROI");
342	>	pmapROI [n].min [0] = atof(argv [++i]);
343	>	pmapROI [n].min [1] = atof(argv [++i]);
344	>	pmapROI [n].min [2] = atof(argv [++i]);
345	>	pmapROI [n].max [0] = atof(argv [++i]);
346	>	pmapROI [n].max [1] = atof(argv [++i]);
347	>	pmapROI [n].max [2] = atof(argv [++i]);
348	>	for (j = 0; j < 3; j++)
349	>	if (pmapROI [n].min [j] >= pmapROI [n].max [j])
350	>	error(USER, "invalid region of interest "
351	>	"(swapped min/max?)");
352	>	break;
353		#endif
301	–	else if (!strcmp(argv [i] + 2, "pP")) {
302	–	/* Global photon precomputation factor */
303	–	check(4, "f");
304	–	finalGather = atof(argv [++i]);
305	–	if (finalGather <= 0 || finalGather > 1)
306	–	error(USER, "global photon precomputation factor "
307	–	"must be in range ]0, 1]");
308	–	}
309	–
310	–	else if (!strcmp(argv [i] + 2, "po") ||
311	–	!strcmp(argv [i] + 2, "pO")) {
312	–	/* Photon port */
313	–	check(4, "s");
314	–
315	–	if (ambincl != 1) {
316	–	ambincl = 1;
317	–	portLp = amblist;
318	–	}
319	–
320	–	if (argv[i][3] == 'O') {
321	–	/* Get port modifiers from file */
322	–	rval = wordfile(portLp, AMBLLEN-(portLp-amblist),
323	–	getpath(argv [++i], getrlibpath(), R_OK));
324	–
325	–	if (rval < 0) {
326	–	sprintf(errmsg, "cannot open photon port file %s",
327	–	argv [i]);
328	–	error(SYSTEM, errmsg);
329	–	}
330	–
331	–	portLp += rval;
332	–	}
333	–
334	–	else {
335	–	/* Append modifier to port list */
336	–	*portLp++ = argv [++i];
337	–	*portLp = NULL;
338	–	}
339	–	}
340	–
341	–	else if (!strcmp(argv [i] + 2, "pr")) {
342	–	/* Random seed */
343	–	check(4, "i");
344	–	randSeed = atoi(argv [++i]);
345	–	}
354
355	<	else if (!strcmp(argv [i] + 2, "ps") ||
356	<	!strcmp(argv [i] + 2, "pS")) {
357	<	/* Antimatter sensor */
358	<	check(4, "s");
359	<
360	<	if (argv[i][3] == 'S') {
361	<	/* Get sensor modifiers from file */
362	<	rval = wordfile(sensLp, MAXSET-(sensLp-photonSensorList),
363	<	getpath(argv [++i], getrlibpath(), R_OK));
364	<
365	<	if (rval < 0) {
366	<	sprintf(errmsg, "cannot open antimatter sensor file %s",
367	<	argv [i]);
368	<	error(SYSTEM, errmsg);
355	>	case 'P': /* Global photon precomp ratio */
356	>	check(4, "f");
357	>	finalGather = atof(argv [++i]);
358	>	if (finalGather <= 0 || finalGather > 1)
359	>	error(USER, "global photon precomputation ratio "
360	>	"must be in range ]0, 1]");
361	>	break;
362	>
363	>	case 'o': /* Photon port */
364	>	case 'O':
365	>	check(4, "s");
366	>	if (argv [i][3] == 'O') {
367	>	/* Add port modifiers from file */
368	>	rval = wordfile(portLp,
369	>	MAXSET - (portLp - photonPortList),
370	>	getpath(argv [++i],
371	>	getrlibpath(), R_OK));
372	>	if (rval < 0) {
373	>	sprintf(errmsg,
374	>	"cannot open photon port file %s",
375	>	argv [i]);
376	>	error(SYSTEM, errmsg);
377	>	}
378	>	portLp += rval;
379	>	}
380	>	else {
381	>	/* Add port modifier from next arg, mark end with
382	>	* NULL */
383	>	*portLp++ = savqstr(argv [++i]);
384	>	*portLp = NULL;
385	>	}
386	>	break;
387	>
388	>	case 'r': /* Random seed */
389	>	check(4, "i");
390	>	randSeed = atoi(argv [++i]);
391	>	break;
392	>
393	>	case 's': /* Antimatter sensor */
394	>	case 'S':
395	>	check(4, "s");
396	>	if (argv[i][3] == 'S') {
397	>	/* Add sensor modifiers from file */
398	>	rval = wordfile(sensLp,
399	>	MAXSET - (sensLp - photonSensorList),
400	>	getpath(argv [++i],
401	>	getrlibpath(), R_OK));
402	>	if (rval < 0) {
403	>	sprintf(errmsg,
404	>	"cannot open antimatter sensor file %s",
405	>	argv [i]);
406	>	error(SYSTEM, errmsg);
407	>	}
408	>	sensLp += rval;
409	>	}
410	>	else {
411	>	/* Append modifier to sensor list, mark end with
412	>	* NULL */
413	>	*sensLp++ = savqstr(argv [++i]);
414	>	*sensLp = NULL;
415	>	}
416	>	break;
417	>
418	>	default: goto badopt;
419		}
420	+	break;
421
422	<	sensLp += rval;
364	<	}
365	<
366	<	else {
367	<	/* Append modifier to sensor list */
368	<	*sensLp++ = argv [++i];
369	<	*sensLp = NULL;
370	<	}
422	>	default: goto badopt;
423		}
372	–
373	–	else goto badopt;
424		break;
425	<
426	<	case 'b':
425	>
426	>	case 'b': /* Back face visibility */
427		if (argv [i][2] == 'v') {
378	–	/* Back face visibility */
428		check_bool(3, backvis);
429		}
381	–
430		else goto badopt;
431		break;
432
#	Line 403 | Line 451 | int main (int argc, char* argv [])
451		diagFile = argv [++i];
452		break;
453
454	<	case 'f':
454	>	case 'f': /* Force overwrite */
455		if (argv [i][2] == 'o') {
408	–	/* Force overwrite */
456		check_bool(3, clobber);
457		}
411	–
458		else goto badopt;
459		break;
460	+
461		#ifdef PMAP_EKSPERTZ
462		case 'l': /* Limits */
463		switch (argv [i][2]) {
#	Line 432 | Line 479 | int main (int argc, char* argv [])
479		}
480		break;
481		#endif
482	+
483		case 'm': /* Medium */
484		switch (argv[i][2]) {
485		case 'e':        /* Eggs-tinction coefficient */
#	Line 456 | Line 504 | int main (int argc, char* argv [])
504		default: goto badopt;
505		}
506		break;
507	+
508		#if NIX
509		case 'n': /* Num parallel processes (NIX only) */
510		check(2, "i");
#	Line 468 | Line 517 | int main (int argc, char* argv [])
517		error(WARNING, errmsg);
518		}
519		break;
520	<	#endif
520	>	#endif
521	>
522		case 't': /* Timer */
523		check(2, "i");
524		photonRepTime = atoi(argv [++i]);
#	Line 476 | Line 526 | int main (int argc, char* argv [])
526
527		case 'v':   /* Verbosity */
528		check_bool(2, verbose);
529	<	break;
529	>	break;
530	>
531		#ifdef EVALDRC_HACK
532		case 'A':   /* Angular source file */
533		check(2,"s");
534		angsrcfile = argv[++i];
535		break;
536	<	#endif
537	<	default: goto badopt;
536	>	#endif
537	>
538	>	default: goto badopt;
539		}
540		}
541

Diff Legend

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