Context Navigation

source: GTP/trunk/Lib/Vis/Preprocessing/src/Environment.cpp @ 2542

Revision 2542, 74.3 KB checked in by mattausch, 17 years ago (diff)

Line
1	// ================================================================
2	// $Id: environ.cpp,v 1.1 2004/02/16 14:45:59 bittner Exp $
3	//
4	// environ.cpp
5	// Implementation of the environment operations, ie. reading
6	// environment file, reading command line parameters etc.
7	//
8
9	//#define _DEBUG_PARAMS
10
11	#include <math.h>
12	#include <stdlib.h>
13	#include <stdio.h>
14	#include <string.h>
15	#include <fstream>
16
17	#include "gzstream.h"
18	#include "common.h"
19	#include "Environment.h"
20	#include "Vector3.h"
21
22	using namespace std;
23
24	namespace GtpVisibilityPreprocessor {
25
26
27	Environment *Environment::sEnvironment = NULL;
28
29
30	Environment *Environment::GetSingleton()
31	{
32	if (!sEnvironment)
33	{
34	sEnvironment = new Environment();
35	}
36
37	return sEnvironment;
38	}
39
40
41	void Environment::DelSingleton()
42	{
43	DEL_PTR(sEnvironment);
44	}
45
46
47	Environment::~Environment()
48	{
49	int i, j;
50
51	// delete the params structure
52	for (i = 0; i < numParams; i++) {
53	for (j = 0; j < paramRows; j++)
54	if (params[i][j] != NULL)
55	delete[] params[i][j];
56	if (params[i] != NULL)
57	delete[] params[i];
58	}
59
60	if (params != NULL)
61	delete[] params;
62
63	// delete the options structure
64	if (options != NULL)
65	delete[] options;
66
67	if (optionalParams != NULL)
68	DEL_PTR(optionalParams);
69	}
70
71	bool
72	Environment::CheckForSwitch(const int argc,
73	char **argv,
74	const char swtch) const
75	{
76	for (int i = 1; i < argc; i++)
77	if ((argv[i][0] == '-') && (argv[i][1] == swtch))
78	return true;
79	return false;
80	}
81
82	bool
83	Environment::CheckType(const char *value,
84	const EOptType type) const
85	{
86	char s, t, *u;
87
88	switch (type) {
89	case optInt: {
90	strtol(value, &t, 10);
91	if (value + strlen(value) != t)
92	return false;
93	else
94	return true;
95	}
96	case optFloat: {
97	strtod(value, &t);
98	if (value + strlen(value) != t)
99	return false;
100	else
101	return true;
102	}
103	case optBool: {
104	if (!strcasecmp(value, "true") \|\|
105	!strcasecmp(value, "false") \|\|
106	!strcasecmp(value, "YES") \|\|
107	!strcasecmp(value, "NO") \|\|
108	!strcmp(value, "+") \|\|
109	!strcmp(value, "-") \|\|
110	!strcasecmp(value, "ON") \|\|
111	!strcasecmp(value, "OFF"))
112	return true;
113	return false;
114	}
115	case optVector:{
116	strtod(value, &s);
117	if (s == ' ' \|\| s == '\t') {
118	while (s == ' ' \|\| s == '\t')
119	s++;
120	if (*s != ',')
121	s--;
122	}
123	if ((s != ',' && s != ' ' && *s != '\t') \|\| value == s)
124	return false;
125	t = s;
126	strtod(s + 1, &u);
127	if (u == ' ' \|\| u == '\t') {
128	while (u == ' ' \|\| u == '\t')
129	u++;
130	if (*u != ',')
131	u--;
132	}
133	if ((u != ',' && s != ' ' && *s != '\t') \|\| t == u)
134	return false;
135	t = u;
136	strtod(u + 1, &s);
137	if (t == s \|\| value + strlen(value) != s)
138	return false;
139	return true;
140	}
141	case optString: {
142	return true;
143	}
144	default: {
145	Debug << "Internal error: Unknown type of option.\n" << flush;
146	exit(1);
147	}
148	}
149	return false;
150	}
151
152	void
153	Environment::ReadCmdlineParams(const int argc,
154	char **argv,
155	const char *optParams)
156	{
157	int i;
158
159	// Make sure we are called for the first time
160	if (optionalParams != NULL)
161	return;
162
163	numParams = (int)strlen(optParams) + 1;
164	optionalParams = new char[numParams];
165	strcpy(optionalParams, optParams);
166
167	// First, count all non-optional parameters on the command line
168	for (i = 1; i < argc; i++)
169	if (argv[i][0] != '-')
170	paramRows++;
171
172	// if there is no non-optional parameter add a default one...
173	if (paramRows == 0)
174	paramRows = 1;
175
176	// allocate and initialize the table for parameters
177	params = new char **[numParams];
178	for (i = 0; i < numParams; i++) {
179	params[i] = new char *[paramRows];
180	for (int j = 0; j < paramRows; j++)
181	params[i][j] = NULL;
182	}
183	// Now read all non-optional and optional parameters into the table
184	curRow = -1;
185	for (i = 1; i < argc; i++) {
186	if (argv[i][0] != '-') {
187	// non-optional parameter encountered
188	curRow++;
189	params[0][curRow] = new char[strlen(argv[i]) + 1];
190	strcpy(params[0][curRow], argv[i]);
191	}
192	else {
193	// option encountered
194	char *t = strchr(optionalParams, argv[i][1]);
195	if (t != NULL) {
196	// this option is optional parameter
197	int index = t - optionalParams + 1;
198	if (curRow < 0) {
199	// it's a global parameter
200	for (int j = 0; j < paramRows; j++) {
201	params[index][j] = new char[strlen(argv[i] + 2) + 1];
202	strcpy(params[index][j], argv[i] + 2);
203	}
204	}
205	else {
206	// it's a scene parameter
207	if (params[index][curRow] != NULL) {
208	delete[] params[index][curRow];
209	}
210	params[index][curRow] = new char[strlen(argv[i] + 2) + 1];
211	strcpy(params[index][curRow], argv[i] + 2);
212	}
213	}
214	}
215	}
216	curRow = 0;
217
218	#ifdef _DEBUG_PARAMS
219	// write out the parameter table
220	cerr << "Parameter table for " << numParams << " columns and "
221	<< paramRows << " rows:\n";
222	for (int j = 0; j < paramRows; j++) {
223	for (i = 0; i < numParams; i++) {
224	if (params[i][j] != NULL)
225	cerr << params[i][j];
226	else
227	cerr << "NULL";
228	cerr << "\t";
229	}
230	cerr << "\n";
231	}
232	cerr << "Params done.\n" << flush;
233	#endif // _DEBUG_PARAMS
234	}
235
236	bool
237	Environment::GetParam(const char name,
238	const int index,
239	char *value) const
240	{
241	int column;
242
243	if (index >= paramRows \|\| index < 0)
244	return false;
245	if (name == ' ')
246	column = 0;
247	else {
248	char *t = strchr(optionalParams, name);
249
250	if (t == NULL)
251	return false;
252	column = t - optionalParams + 1;
253	}
254
255	if (params[column][index] == NULL)
256	return false;
257	// value = new char[strlen(params[column][index]) + 1];
258	strcpy(value, params[column][index]);
259	return true;
260	}
261
262	void
263	Environment::RegisterOption(const char *name,
264	const EOptType type,
265	const char *abbrev,
266	const char *defValue)
267	{
268	int i;
269
270	// make sure this option was not yet registered
271	for (i = 0; i < numOptions; i++)
272	if (!strcmp(name, options[i].name)) {
273	Debug << "Error: Option " << name << " registered twice.\n";
274	exit(1);
275	}
276	// make sure we have enough room in memory
277	if (numOptions >= maxOptions) {
278	Debug << "Error: Too many options. Try enlarge the maxOptions "
279	<< "definition.\n";
280	exit(1);
281	}
282
283	// make sure the abbreviation doesn't start with 'D'
284	if (abbrev != NULL && (abbrev[0] == 'D' )) {
285	Debug << "Internal error: reserved switch " << abbrev
286	<< " used as an abbreviation.\n";
287	exit(1);
288	}
289	// new option
290	options[numOptions].type = type;
291	options[numOptions].name = ::strdup(name);
292	// assign abbreviation, if requested
293	if (abbrev != NULL) {
294	options[numOptions].abbrev = ::strdup(abbrev);
295	}
296	// assign default value, if requested
297	if (defValue != NULL) {
298	options[numOptions].defaultValue = ::strdup(defValue);
299	if (!CheckType(defValue, type)) {
300	Debug << "Internal error: Inconsistent type and default value in option "
301	<< name << ".\n";
302	exit(1);
303	}
304	}
305	// new option registered
306	numOptions++;
307	}
308
309	bool
310	Environment::OptionPresent(const char *name) const
311	{
312	bool found = false;
313	int i;
314
315	for (i = 0; i < numOptions; i++)
316	if (!strcmp(options[i].name, name)) {
317	found = true;
318	break;
319	}
320	if (!found) {
321	Debug << "Internal error: Option " << name << " not registered.\n" << flush;
322	exit(1);
323	}
324	if (options[i].value != NULL \|\| options[i].defaultValue != NULL)
325	return true;
326	else
327	return false;
328	}
329
330	int
331	Environment::FindOption(const char *name, const bool isFatal) const
332	{
333	int i;
334	bool found = false;
335	// is this option registered ?
336	for (i = 0; i < numOptions; i++)
337	if (!strcmp(options[i].name, name)) {
338	found = true;
339	break;
340	}
341	if (!found) {
342	// no registration found
343	Debug << "Internal error: Required option " << name
344	<< " not registered.\n" << flush;
345	exit(1);
346	}
347	if (options[i].value == NULL && options[i].defaultValue == NULL)
348	// this option was not initialised to some value
349	if (isFatal) {
350	Debug << "Error: Required option " << name << " not found.\n" << flush;
351	exit(1);
352	}
353	else {
354	Debug << "Error: Required option " << name << " not found.\n" << flush;
355	return -1;
356	}
357	return i;
358	}
359
360	bool
361	Environment::GetIntValue(const char *name,
362	int &value,
363	const bool isFatal) const
364	{
365	int i = FindOption(name, isFatal);
366
367	if (i<0)
368	return false;
369
370	if (options[i].value != NULL) {
371	// option was explicitly specified
372	value = strtol(options[i].value, NULL, 10);
373	} else {
374	// option was not read, so use the default
375	value = strtol(options[i].defaultValue, NULL, 10);
376	}
377
378	return true;
379	}
380
381	bool
382	Environment::GetDoubleValue(const char *name,
383	double &value,
384	const bool isFatal) const
385	{
386	int i = FindOption(name, isFatal);
387
388	if (i<0)
389	return false;
390
391	if (options[i].value != NULL) {
392	// option was explicitly specified
393	value = strtod(options[i].value, NULL);
394	} else {
395	// option was not read, so use the default
396	value = strtod(options[i].defaultValue, NULL);
397	}
398	return true;
399	}
400
401	bool
402	Environment::GetRealValue(const char *name,
403	Real &value,
404	const bool isFatal) const
405	{
406	int i = FindOption(name, isFatal);
407
408	if (i<0)
409	return false;
410
411	if (options[i].value != NULL) {
412	// option was explicitly specified
413	value = (Real)strtod(options[i].value, NULL);
414	} else {
415	// option was not read, so use the default
416	value = (Real)strtod(options[i].defaultValue, NULL);
417	}
418	return true;
419	}
420
421	bool
422	Environment::GetFloatValue(const char *name,
423	float &value,
424	const bool isFatal) const
425	{
426	int i = FindOption(name, isFatal);
427
428	if (i<0)
429	return false;
430
431	if (options[i].value != NULL) {
432	// option was explicitly specified
433	value = (float)strtod(options[i].value, NULL);
434	} else {
435	// option was not read, so use the default
436	value = (float)strtod(options[i].defaultValue, NULL);
437	}
438	return true;
439	}
440
441	bool
442	Environment::GetBool(const char *name,
443	const bool isFatal) const
444	{
445	bool ret;
446	if (GetBoolValue(name, ret, isFatal))
447	return ret;
448	else
449	return false;
450	}
451
452	bool
453	Environment::ParseBool(const char *name) const
454	{
455
456	bool value = true;
457
458	if (!strcasecmp(name, "false") \|\|
459	!strcasecmp(name, "NO") \|\|
460	!strcmp(name, "-") \|\|
461	!strcasecmp(name, "OFF"))
462	value = false;
463
464	return value;
465	}
466
467	void
468	Environment::ParseVector(const char *name, Vector3 &v) const
469	{
470	// option was not read, so use the default
471	char s, t;
472
473	v.x = (Real)strtod(name, &s);
474	v.y = (Real)strtod(s + 1, &t);
475	v.z = (Real)strtod(t + 1, NULL);
476
477	}
478
479	bool
480	Environment::GetBoolValue(const char *name,
481	bool &value,
482	const bool isFatal) const
483	{
484	int i = FindOption(name, isFatal);
485
486	if (i<0)
487	return false;
488
489
490	if (options[i].value != NULL)
491	value = ParseBool(options[i].value);
492	else
493	value = ParseBool(options[i].defaultValue);
494
495	return true;
496	}
497
498	bool
499	Environment::GetVectorValue(const char *name,
500	Vector3 &v,
501	const bool isFatal) const
502	{
503	int i = FindOption(name, isFatal);
504	if (i<0)
505	return false;
506
507	if (options[i].value != NULL)
508
509
510	if (options[i].value != NULL) {
511	ParseVector(options[i].value, v);
512	}
513	else {
514	ParseVector(options[i].defaultValue, v);
515	}
516	return true;
517	}
518
519	bool
520	Environment::GetStringValue(const char *name,
521	char *value,
522	const bool isFatal) const
523	{
524	int i = FindOption(name, isFatal);
525
526	if (i<0)
527	return false;
528
529
530	if (options[i].value != NULL) {
531	// option was not read, so use the default
532	strcpy(value, options[i].value);
533	}
534	else {
535	// option was explicitly specified
536	strcpy(value, options[i].defaultValue);
537	}
538	return true;
539	}
540
541	void
542	Environment::SetInt(const char *name, const int value)
543	{
544
545	int i = FindOption(name);
546	if (i<0)
547	return;
548
549	if (options[i].type == optInt) {
550	delete options[i].value;
551	options[i].value = new char[16];
552	sprintf(options[i].value, "%.15d", value);
553	}
554	else {
555	Debug << "Internal error: Trying to set non-integer option " << name
556	<< " to integral value.\n" << flush;
557	exit(1);
558	}
559	}
560
561	void
562	Environment::SetFloat(const char *name, const Real value)
563	{
564	int i = FindOption(name);
565	if (i<0)
566	return;
567
568	if (options[i].type == optFloat) {
569	delete options[i].value;
570	options[i].value = new char[25];
571	sprintf(options[i].value, "%.15e", value);
572	}
573	else {
574	Debug << "Internal error: Trying to set non-Real option " << name
575	<< " to Real value.\n" << flush;
576	exit(1);
577	}
578	}
579
580	void
581	Environment::SetBool(const char *name, const bool value)
582	{
583	int i = FindOption(name);
584	if (i<0)
585	return;
586
587	if (options[i].type == optBool) {
588	delete options[i].value;
589	options[i].value = new char[6];
590	if (value)
591	sprintf(options[i].value, "true");
592	else
593	sprintf(options[i].value, "false");
594	}
595	else {
596	Debug << "Internal error: Trying to set non-bool option " << name
597	<< " to boolean value.\n" << flush;
598	exit(1);
599	}
600	}
601
602	void
603	Environment::SetVector(const char *name,
604	const Vector3 &v)
605	{
606	int i = FindOption(name);
607	if (i<0)
608	return;
609
610	if (options[i].type == optVector) {
611	delete options[i].value;
612	options[i].value = new char[128];
613	sprintf(options[i].value, "%.15e,%.15e,%.15e", v.x, v.y, v.z);
614	}
615	else {
616	Debug << "Internal error: Trying to set non-vector option " << name
617	<< " to vector value.\n" << flush;
618	exit(1);
619	}
620	}
621
622	void
623	Environment::SetString(const char name, const char value)
624	{
625	int i = FindOption(name);
626	if (i<0)
627	return;
628
629	if (options[i].type == optString) {
630	delete options[i].value;
631	options[i].value = ::strdup(value);
632	}
633	else {
634	Debug << "Internal error: Trying to set non-string option " << name
635	<< " to string value.\n" << flush;
636	exit(1);
637	}
638	}
639
640	void
641	Environment::ParseCmdline(const int argc,
642	char **argv,
643	const int index)
644	{
645	int curIndex = -1;
646
647	for (int i = 1; i < argc; i++) {
648	// if this parameter is non-optional, skip it and increment the counter
649	if (argv[i][0] != '-') {
650	curIndex++;
651	continue;
652	}
653	// make sure to skip all non-optional parameters
654	char *t = strchr(optionalParams, argv[i][1]);
655	if (t != NULL)
656	continue;
657
658	// if we are in the scope of the current parameter, parse it
659	if (curIndex == -1 \|\| curIndex == index) {
660	if (argv[i][1] == 'D') {
661	// it's a full name definition
662	bool found = false;
663	int j;
664
665	char *t = strchr(argv[i] + 2, '=');
666	if (t == NULL) {
667	Debug << "Error: Missing '=' in option. "
668	<< "Syntax is -D<name>=<value>.\n" << flush;
669	exit(1);
670	}
671	for (j = 0; j < numOptions; j++)
672	if (!strncmp(options[j].name, argv[i] + 2, t - argv[i] - 2) &&
673	(unsigned)(t - argv[i] - 2) == strlen(options[j].name)) {
674	found = true;
675	break;
676	}
677	if (!found) {
678	Debug << "Warning: Unregistered option " << argv[i] << ".\n" << flush;
679	// exit(1);
680	}
681	if (found) {
682	if (!CheckType(t + 1, options[j].type)) {
683	Debug << "Error: invalid type of value " << t + 1 << " in option "
684	<< options[j].name << ".\n";
685	exit(1);
686	}
687	if (options[j].value != NULL)
688	delete options[j].value;
689	options[j].value = strdup(t + 1);
690	}
691	}
692	else {
693	// it's an abbreviation
694	bool found = false;
695	int j;
696
697	for (j = 0; j < numOptions; j++)
698	if (options[j].abbrev != NULL &&
699	!strncmp(options[j].abbrev, argv[i] + 1, strlen(options[j].abbrev))) {
700	found = true;
701	break;
702	}
703	if (!found) {
704	Debug << "Warning: Unregistered option " << argv[i] << ".\n" << flush;
705	// exit(1);
706	}
707	if (found) {
708	if (!CheckType(argv[i] + 1 + strlen(options[j].abbrev), options[j].type)) {
709	Debug << "Error: invalid type of value "
710	<< argv[i] + 1 + strlen(options[j].abbrev) << "in option "
711	<< options[j].name << ".\n";
712	exit(1);
713	}
714	if (options[j].value != NULL)
715	delete options[j].value;
716	options[j].value = strdup(argv[i] + 1 + strlen(options[j].abbrev));
717	}
718	}
719	}
720	}
721	#ifdef _DEBUG_PARAMS
722	// write out the options table
723	cerr << "Options table for " << numOptions << " options:\n";
724	for (int j = 0; j < numOptions; j++) {
725	cerr << options[j];
726	cerr << "\n";
727	}
728	cerr << "Options done.\n" << flush;
729	#endif // _DEBUG_PARAMS
730	}
731
732
733	char *
734	Environment::ParseString(char buffer, char string) const
735	{
736	char *s = buffer;
737	char *t = string + strlen(string);
738
739	// skip leading whitespaces
740	while (s == ' ' \|\| s == '\t')
741	s++;
742	if (*s == '\0')
743	return NULL;
744	while ((s >= 'a' && s <= 'z') \|\|
745	(s >= 'A' && s <= 'Z') \|\|
746	(s >= '0' && s <= '9') \|\|
747	*s == '_')
748	t++ = s++;
749	*t = '\0';
750	// skip trailing whitespaces
751	while (s == ' ' \|\| s == '\t')
752	s++;
753	return s;
754	}
755
756	const char code[] = "JIDHipewhfdhyd74387hHO&{WK:DOKQEIDKJPQH#@USX:#FWCQEJMQAHPQP(@G#RD";
757
758	void
759	Environment::DecodeString(char *buff, int max)
760	{
761	buff[max] = 0;
762	char *p = buff;
763	const char *cp = code;
764	for (; *p; p++) {
765	if (*p != '\n')
766	p = p ^ *cp;
767	++cp;
768	if (*cp == 0)
769	cp = code;
770	}
771	}
772
773	void
774	Environment::CodeString(char *buff, int max)
775	{
776	buff[max] = 0;
777	char *p = buff;
778	const char *cp = code;
779	for (; *p; p++) {
780	if (*p != '\n')
781	p = p ^ *cp;
782	++cp;
783	if (*cp == 0)
784	cp = code;
785	}
786	}
787
788	void
789	Environment::SaveCodedFile(char *filenameText,
790	char *filenameCoded)
791	{
792	ifstream envStream(filenameText);
793
794	// some error had occured
795	if (envStream.fail()) {
796	cerr << "Error: Can't open file " << filenameText << " for reading (err. "
797	<< envStream.rdstate() << ").\n";
798	return;
799	}
800
801	char buff[256];
802	envStream.getline(buff, 255);
803	buff[8] = 0;
804	if (strcmp(buff, "CGX_CF10") == 0)
805	return;
806
807	ofstream cStream(filenameCoded);
808	cStream<<"CGX_CF10";
809
810	// main loop
811	for (;;) {
812	// read in one line
813	envStream.getline(buff, 255);
814	if (!envStream)
815	break;
816	CodeString(buff, 255);
817	cStream<<buff;
818	}
819
820	}
821
822	bool
823	Environment::ReadEnvFile(const char *envFilename)
824	{
825	char buff[MaxStringLength], name[MaxStringLength];
826	char s, t;
827	int i, line = 0;
828	bool found;
829	igzstream envStream(envFilename);
830
831	// some error had occured
832	if (envStream.fail()) {
833	cerr << "Error: Can't open file " << envFilename << " for reading (err. "
834	<< envStream.rdstate() << ").\n";
835	return false;
836	}
837
838	name[0] = '\0';
839
840	// bool coded;
841	// envStream.getline(buff, 255);
842	// buff[8] = 0;
843	// if (strcmp(buff, "CGX_CF10") == 0)
844	// coded = true;
845	// else {
846	// coded = false;
847	// envStream.Rewind();
848	// }
849
850	// main loop
851	for (;;) {
852	// read in one line
853	envStream.getline(buff, MaxStringLength-1);
854
855	if (!envStream)
856	break;
857
858	// if (coded)
859	// DecodeString(buff, 255);
860
861	line++;
862	// get rid of comments
863	s = strchr(buff, '#');
864	if (s != NULL)
865	*s = '\0';
866
867	// get one identifier
868	s = ParseString(buff, name);
869	// parse line
870	while (s != NULL) {
871	// it's a group name - make the full name
872	if (*s == '{') {
873	strcat(name, ".");
874	s++;
875	s = ParseString(s, name);
876	continue;
877	}
878	// end of group
879	if (*s == '}') {
880	if (strlen(name) == 0) {
881	cerr << "Error: unpaired } in " << envFilename << " (line "
882	<< line << ").\n";
883	envStream.close();
884	return false;
885	}
886	name[strlen(name) - 1] = '\0';
887	t = strrchr(name, '.');
888	if (t == NULL)
889	name[0] = '\0';
890	else
891	*(t + 1) = '\0';
892	s++;
893	s = ParseString(s, name);
894	continue;
895	}
896	// find variable name in the table
897	found = false;
898	for (i = 0; i < numOptions; i++)
899	if (!strcmp(name, options[i].name)) {
900	found = true;
901	break;
902	}
903	if (!found) {
904	cerr << "Warning: unknown option " << name << " in environment file "
905	<< envFilename << " (line " << line << ").\n";
906	} else
907	switch (options[i].type) {
908	case optInt: {
909	strtol(s, &t, 10);
910	if (t == s \|\| (t != ' ' && t != '\t' &&
911	t != '\0' && t != '}')) {
912	cerr << "Error: Mismatch in int variable " << name << " in "
913	<< "environment file " << envFilename << " (line "
914	<< line << ").\n";
915	envStream.close();
916	return false;
917	}
918	if (options[i].value != NULL)
919	delete options[i].value;
920	options[i].value = new char[t - s + 1];
921	strncpy(options[i].value, s, t - s);
922	options[i].value[t - s] = '\0';
923	s = t;
924	break;
925	}
926	case optFloat: {
927	strtod(s, &t);
928	if (t == s \|\| (t != ' ' && t != '\t' &&
929	t != '\0' && t != '}')) {
930	cerr << "Error: Mismatch in Real variable " << name << " in "
931	<< "environment file " << envFilename << " (line "
932	<< line << ").\n";
933	envStream.close();
934	return false;
935	}
936	if (options[i].value != NULL)
937	delete options[i].value;
938	options[i].value = new char[t - s + 1];
939	strncpy(options[i].value, s, t - s);
940	options[i].value[t - s] = '\0';
941	s = t;
942	break;
943	}
944	case optBool: {
945	t = s;
946	while ((t >= 'a' && t <= 'z') \|\|
947	(t >= 'A' && t <= 'Z') \|\|
948	t == '+' \|\| t == '-')
949	t++;
950	if (((!strncasecmp(s, "true", t - s) && t - s == 4) \|\|
951	(!strncasecmp(s, "false", t - s) && t - s == 5) \|\|
952	(!strncasecmp(s, "YES", t -s) && t - s == 3) \|\|
953	(!strncasecmp(s, "NO", t - s) && t - s == 2) \|\|
954	(!strncasecmp(s, "ON", t - s) && t - s == 2) \|\|
955	(!strncasecmp(s, "OFF", t - s) && t - s == 3) \|\|
956	(t - s == 1 && (s == '+' \|\| s == '-'))) &&
957	(t == ' ' \|\| t == '\t' \|\| t == '\0' \|\| t == '}')) {
958	if (options[i].value != NULL)
959	delete options[i].value;
960	options[i].value = new char[t - s + 1];
961	strncpy(options[i].value, s, t - s);
962	options[i].value[t - s] = '\0';
963	s = t;
964	}
965	else {
966	cerr << "Error: Mismatch in bool variable " << name << " in "
967	<< "environment file " << envFilename << " (line "
968	<< line << ").\n";
969	envStream.close();
970	return false;
971	}
972	break;
973	}
974	case optVector:{
975	strtod(s, &t);
976	if (t == ' ' \|\| t == '\t') {
977	while (t == ' ' \|\| t == '\t')
978	t++;
979	if (*t != ',')
980	t--;
981	}
982	if (t == s \|\| (t != ' ' && t != '\t' && *t != ',')) {
983	cerr << "Error: Mismatch in vector variable " << name << " in "
984	<< "environment file " << envFilename << " (line "
985	<< line << ").\n";
986	envStream.close();
987	return false;
988	}
989	char *u;
990	strtod(t, &u);
991	t = u;
992	if (t == ' ' \|\| t == '\t') {
993	while (t == ' ' \|\| t == '\t')
994	t++;
995	if (*t != ',')
996	t--;
997	}
998	if (t == s \|\| (t != ' ' && t != '\t' && *t != ',')) {
999	cerr << "Error: Mismatch in vector variable " << name << " in "
1000	<< "environment file " << envFilename << " (line "
1001	<< line << ").\n";
1002	envStream.close();
1003	return false;
1004	}
1005	strtod(t, &u);
1006	t = u;
1007	if (t == s \|\| (t != ' ' && t != '\t' &&
1008	t != '\0' && t != '}')) {
1009	cerr << "Error: Mismatch in vector variable " << name << " in "
1010	<< "environment file " << envFilename << " (line "
1011	<< line << ").\n";
1012	envStream.close();
1013	return false;
1014	}
1015	if (options[i].value != NULL)
1016	delete options[i].value;
1017	options[i].value = new char[t - s + 1];
1018	strncpy(options[i].value, s, t - s);
1019	options[i].value[t - s] = '\0';
1020	s = t;
1021	break;
1022	}
1023	case optString: {
1024	if (options[i].value != NULL)
1025	delete options[i].value;
1026	options[i].value = new char[strlen(s) + 1];
1027	strcpy(options[i].value, s);
1028	s += strlen(s);
1029	break;
1030	}
1031	default: {
1032	Debug << "Internal error: Unknown type of option.\n" << flush;
1033	exit(1);
1034	}
1035	}
1036	// prepare the variable name for next pass
1037	t = strrchr(name, '.');
1038	if (t == NULL)
1039	name[0] = '\0';
1040	else
1041	*(t + 1) = '\0';
1042	// get next identifier
1043	s = ParseString(s, name);
1044	}
1045	}
1046	envStream.close();
1047	return true;
1048	}
1049
1050	void
1051	Environment::PrintUsage(ostream &s) const
1052	{
1053	// Print out all environment variable names
1054	s << "Registered options:\n";
1055	for (int j = 0; j < numOptions; j++)
1056	s << options[j] << "\n";
1057	s << flush;
1058	}
1059
1060	/**
1061	Input scene filename. Currently simplified X3D (.x3d), Unigraphics (.dat),
1062	and UNC (.ply) formats are supported.
1063	*/
1064
1065	Environment::Environment()
1066	{
1067	optionalParams = NULL;
1068	paramRows = 0;
1069	numParams = 0;
1070	params = NULL;
1071	maxOptions = 500;
1072
1073
1074	// this is maximal nuber of options.
1075	numOptions = 0;
1076
1077	options = new COption[maxOptions];
1078
1079	if (options == NULL ) {
1080	Debug << "Error: Memory allocation failed.\n";
1081	exit(1);
1082	}
1083
1084	// register all basic options
1085
1086	RegisterOption("Limits.threshold", optFloat, NULL, "0.01");
1087	RegisterOption("Limits.small", optFloat, NULL, "1e-6");
1088	RegisterOption("Limits.infinity", optFloat, NULL, "1e6");
1089
1090	RegisterOption("Scene.filename",
1091	optString,
1092	"scene_filename=",
1093	"atlanta2.x3d");
1094
1095	RegisterOption("Unigraphics.meshGrouping",
1096	optInt,
1097	"unigraphics_mesh_grouping=",
1098	"0");
1099
1100	RegisterOption("ObjParser.meshGrouping",
1101	optInt,
1102	"objparser_mesh_grouping=",
1103	"0");
1104
1105	RegisterOption("KdTree.Termination.minCost",
1106	optInt,
1107	"kd_term_min_cost=",
1108	"10");
1109
1110	RegisterOption("KdTree.Termination.maxNodes",
1111	optInt,
1112	"kd_term_max_nodes=",
1113	"200000");
1114
1115	RegisterOption("KdTree.Termination.maxDepth",
1116	optInt,
1117	"kd_term_max_depth=",
1118	"20");
1119
1120	RegisterOption("KdTree.Termination.maxCostRatio",
1121	optFloat,
1122	"kd_term_max_cost_ratio=",
1123	"1.5");
1124
1125	RegisterOption("KdTree.Termination.ct_div_ci",
1126	optFloat,
1127	"kd_term_ct_div_ci=",
1128	"1.0");
1129
1130	RegisterOption("KdTree.splitMethod",
1131	optString,
1132	"kd_split_method=",
1133	"spatialMedian");
1134
1135	RegisterOption("KdTree.pvsArea",
1136	optFloat,
1137	"kd_pvs_area=",
1138	"1e-4");
1139
1140	RegisterOption("KdTree.splitBorder",
1141	optFloat,
1142	"kd_split_border=",
1143	"0.1");
1144
1145	RegisterOption("KdTree.sahUseFaces",
1146	optBool,
1147	"kd_sah_use_faces=",
1148	"true");
1149
1150	RegisterOption("MeshKdTree.Termination.minCost",
1151	optInt,
1152	"kd_term_min_cost=",
1153	"10");
1154
1155	RegisterOption("MeshKdTree.Termination.maxDepth",
1156	optInt,
1157	"kd_term_max_depth=",
1158	"20");
1159
1160	RegisterOption("MeshKdTree.Termination.maxCostRatio",
1161	optFloat,
1162	"kd_term_max_cost_ratio=",
1163	"1.5");
1164
1165	RegisterOption("MeshKdTree.Termination.ct_div_ci",
1166	optFloat,
1167	"kd_term_ct_div_ci=",
1168	"1.0");
1169
1170	RegisterOption("MeshKdTree.splitMethod",
1171	optString,
1172	"kd_split_method=",
1173	"spatialMedian");
1174
1175	RegisterOption("MeshKdTree.splitBorder",
1176	optFloat,
1177	"kd_split_border=",
1178	"0.1");
1179
1180	RegisterOption("Preprocessor.totalSamples",
1181	optInt,
1182	"total_samples=",
1183	"10000000");
1184
1185	RegisterOption("Preprocessor.totalTime",
1186	optInt,
1187	"total_time=",
1188	"-1");
1189
1190	RegisterOption("Preprocessor.samplesPerPass",
1191	optInt,
1192	"samples_per_pass=",
1193	"100000");
1194
1195	RegisterOption("Preprocessor.samplesPerEvaluation",
1196	optInt,
1197	"samples_per_evaluation=",
1198	"1000000");
1199
1200	RegisterOption("Preprocessor.useHwGlobalLines",
1201	optBool,
1202	"preprocessor_use_hw_global_lines=",
1203	"false");
1204
1205	RegisterOption("Preprocessor.HwGlobalLines.texHeight",
1206	optInt,
1207	"preprocessor_hw_global_lines_texheight=",
1208	"128");
1209
1210	RegisterOption("Preprocessor.HwGlobalLines.texWidth",
1211	optInt,
1212	"preprocessor_hw_global_lines_texwidth=",
1213	"128");
1214
1215	RegisterOption("Preprocessor.HwGlobalLines.stepSize",
1216	optFloat,
1217	"preprocessor_hw_global_lines_stepsize=",
1218	"0.0001");
1219
1220	RegisterOption("Preprocessor.HwGlobalLines.maxDepth",
1221	optInt,
1222	"preprocessor_hw_global_lines_max_depth=",
1223	"50");
1224
1225	RegisterOption("Preprocessor.HwGlobalLines.sampleReverse",
1226	optBool,
1227	"preprocessor_hw_global_lines_sample_reverse=",
1228	"true");
1229
1230	RegisterOption("RenderSampler.samples",
1231	optInt,
1232	"render_sampler_samples=",
1233	"1000");
1234
1235	RegisterOption("RenderSampler.visibleThreshold",
1236	optInt,
1237	"render_sampler_visible_threshold=",
1238	"0");
1239
1240	RegisterOption("RenderSampler.useOcclusionQueries",
1241	optBool,
1242	"render_sampler_use_occlusion_queries=",
1243	"true");
1244
1245	RegisterOption("VssPreprocessor.testBeamSampling",
1246	optBool,
1247	"vss_beam_sampling=",
1248	"false");
1249
1250	RegisterOption("VssPreprocessor.useImportanceSampling",
1251	optBool,
1252	"vss_use_importance=",
1253	"true");
1254
1255
1256	RegisterOption("VssPreprocessor.enlargeViewSpace",
1257	optBool,
1258	"vss_enlarge_viewspace=",
1259	"false");
1260
1261	RegisterOption("VssPreprocessor.loadInitialSamples",
1262	optBool,
1263	"vss_load_loadInitialSamples=",
1264	"false");
1265
1266	RegisterOption("VssPreprocessor.storeInitialSamples",
1267	optBool,
1268	"vss_store_storedInitialSamples=",
1269	"false");
1270
1271
1272
1273	/*************************************************************************/
1274	/* Mutation strategy related options */
1275	/*************************************************************************/
1276
1277	RegisterOption("Mutation.bufferSize",
1278	optInt,
1279	"mutation_buffer_size=",
1280	"500000");
1281
1282	RegisterOption("Mutation.radiusOrigin",
1283	optFloat,
1284	"mutation_radius_origin=",
1285	"0.5");
1286
1287	RegisterOption("Mutation.radiusTermination",
1288	optFloat,
1289	"mutation_radius_termination=",
1290	"0.5");
1291
1292	RegisterOption("Mutation.useReverseSamples",
1293	optBool,
1294	"mutation_use_reverse_samples",
1295	"true");
1296
1297	RegisterOption("Mutation.reverseSamplesDistance",
1298	optFloat,
1299	"mutation_reverse_samples_distance=",
1300	"3.0");
1301
1302	RegisterOption("Mutation.useSilhouetteSamples",
1303	optBool,
1304	"mutation_use_silhouette_samples",
1305	"true");
1306
1307	RegisterOption("Mutation.silhouetteSearchSteps",
1308	optInt,
1309	"mutation_silhouette_search_steps=",
1310	"3");
1311
1312	RegisterOption("Mutation.silhouetteProb",
1313	optFloat,
1314	"mutation_silhouette_prob=",
1315	"0.8");
1316
1317	RegisterOption("Mutation.usePassImportance",
1318	optBool,
1319	"mutation_use_pass_importance",
1320	"true");
1321
1322	RegisterOption("Mutation.useUnsuccCountImportance",
1323	optBool,
1324	"mutation_use_unsucc_count_importance",
1325	"false");
1326
1327
1328	/*************************************************************************/
1329	/* GvsPrerpocessor related options */
1330	/*************************************************************************/
1331
1332
1333	RegisterOption("GvsPreprocessor.totalSamples",
1334	optInt,
1335	"gvs_total_samples=",
1336	"1000000");
1337
1338	RegisterOption("GvsPreprocessor.gvsSamplesPerPass",
1339	optInt,
1340	"gvs_samples_per_pass=",
1341	"100000");
1342
1343	RegisterOption("GvsPreprocessor.initialSamples",
1344	optInt,
1345	"gvs_initial_samples=",
1346	"256");
1347
1348	RegisterOption("GvsPreprocessor.epsilon",
1349	optFloat,
1350	"gvs_epsilon=",
1351	"0.00001");
1352
1353	RegisterOption("GvsPreprocessor.threshold",
1354	optFloat,
1355	"gvs_threshold=",
1356	"1.5");
1357
1358	RegisterOption("GvsPreprocessor.perViewCell",
1359	optBool,
1360	"gvs_per_viewcell=",
1361	"true");
1362
1363	RegisterOption("GvsPreprocessor.stats",
1364	optString,
1365	"gvs_stats=",
1366	"gvsStats.log");
1367
1368	RegisterOption("GvsPreprocessor.minContribution",
1369	optInt,
1370	"gvs_min_contribution=",
1371	"50");
1372
1373	RegisterOption("GvsPreprocessor.maxViewCells",
1374	optInt,
1375	"gvs_max_viewcells=",
1376	"5");
1377
1378
1379	/**********************************************************************/
1380	/* View cells related options */
1381	/**********************************************************************/
1382
1383
1384	RegisterOption("ViewCells.type",
1385	optString,
1386	"view_cells_type=",
1387	"vspBspTree");
1388
1389	RegisterOption("ViewCells.samplingType",
1390	optString,
1391	"view_cells_sampling_type=",
1392	"box");
1393
1394	RegisterOption("ViewCells.mergeStats",
1395	optString,
1396	"view_cells_merge_stats=",
1397	"mergeStats.log");
1398
1399	RegisterOption("ViewCells.Evaluation.statsPrefix",
1400	optString,
1401	"view_cells_evaluation_stats_prefix=",
1402	"viewCells");
1403
1404	RegisterOption("ViewCells.Evaluation.histogram",
1405	optBool,
1406	"view_cells_evaluation_histogram=",
1407	"false");
1408
1409	RegisterOption("ViewCells.Evaluation.histoStepSize",
1410	optInt,
1411	"view_cells_evaluation_histo_step_size=",
1412	"5000");
1413
1414	RegisterOption("ViewCells.Evaluation.histoMem",
1415	optInt,
1416	"view_cells_evaluation_histo_mem=",
1417	"50");
1418
1419	RegisterOption("ViewCells.active",
1420	optInt,
1421	"view_cells_active=",
1422	"1000");
1423
1424	RegisterOption("ViewCells.Construction.samples",
1425	optInt,
1426	"view_cells_construction_samples=",
1427	"0");
1428
1429	RegisterOption("ViewCells.Construction.samplesPerPass",
1430	optInt,
1431	"view_cells_construction_samples_per_pass=",
1432	"500000");
1433
1434	RegisterOption("ViewCells.PostProcess.samples",
1435	optInt,
1436	"view_cells_post_process_samples=",
1437	"0");
1438
1439	RegisterOption("ViewCells.Visualization.samples",
1440	optInt,
1441	"view_cells_visualization_samples=",
1442	"0");
1443
1444	RegisterOption("ViewCells.Visualization.maxOutput",
1445	optInt,
1446	"view_cells_visualization_max_output=",
1447	"20");
1448
1449	RegisterOption("ViewCells.Filter.maxSize",
1450	optInt,
1451	"view_cells_filter_max_size=",
1452	"4");
1453
1454	RegisterOption("ViewCells.Filter.width",
1455	optFloat,
1456	"view_cells_filter_width=",
1457	"1.0");
1458
1459	RegisterOption("ViewCells.loadFromFile",
1460	optBool,
1461	"view_cells_load_from_file=",
1462	"false");
1463
1464	RegisterOption("ViewCells.PostProcess.refine",
1465	optBool,
1466	"view_cells_refine=",
1467	"false");
1468
1469	RegisterOption("ViewCells.PostProcess.compress",
1470	optBool,
1471	"view_cells_post_process_compress=",
1472	"false");
1473
1474	RegisterOption("ViewCells.Evaluation.samples",
1475	optInt,
1476	"view_cells_evaluation_samples=",
1477	"8000000");
1478
1479	RegisterOption("ViewCells.Evaluation.samplingType",
1480	optString,
1481	"view_cells_evaluation_sampling_type=",
1482	"box");
1483
1484	RegisterOption("ViewCells.Evaluation.samplesPerPass",
1485	optInt,
1486	"view_cells_evaluation_samples_per_pass=",
1487	"300000");
1488
1489	RegisterOption("ViewCells.Evaluation.samplesForStats",
1490	optInt,
1491	"view_cells_evaluation_samples_for_stats=",
1492	"300000");
1493
1494	RegisterOption("ViewCells.exportToFile",
1495	optBool,
1496	"view_cells_export_to_file=",
1497	"false");
1498
1499	RegisterOption("ViewCells.exportPvs",
1500	optBool,
1501	"view_cells_export_pvs=",
1502	"false");
1503
1504	RegisterOption("ViewCells.exportBboxesForPvs",
1505	optBool,
1506	"view_cells_export_bounding_boxes=",
1507	"true");
1508
1509	RegisterOption("ViewCells.boxesFilename",
1510	optString,
1511	"view_cells_boxes_filename=",
1512	"boxes.out");
1513
1514	RegisterOption("ViewCells.evaluateViewCells",
1515	optBool,
1516	"view_cells_evaluate=",
1517	"false");
1518
1519	RegisterOption("ViewCells.maxViewCells",
1520	optInt,
1521	"view_cells_max_view_cells=",
1522	"0");
1523
1524	RegisterOption("ViewCells.Evaluation.stepSize",
1525	optInt,
1526	"view_cells_evaluation_step_size=",
1527	"100");
1528
1529	RegisterOption("ViewCells.maxPvsRatio",
1530	optFloat,
1531	"view_cells_max_pvs_ratio=",
1532	"0.1");
1533
1534	RegisterOption("ViewCells.triangleWeight",
1535	optFloat,
1536	"view_cells_triangle_weight=",
1537	"1.0");
1538
1539	RegisterOption("ViewCells.objectWeight",
1540	optFloat,
1541	"view_cells_object_weight=",
1542	"0.0");
1543
1544	RegisterOption("ViewCells.filename",
1545	optString,
1546	"view_cells_filename=",
1547	"atlanta_viewcells_large.x3d");
1548
1549	RegisterOption("ViewCells.height",
1550	optFloat,
1551	"view_cells_height=",
1552	"5.0");
1553
1554	RegisterOption("ViewCells.Visualization.colorCode",
1555	optString,
1556	"view_cells_visualization_color_code=",
1557	"PVS");
1558
1559	RegisterOption("ViewCells.Visualization.clipPlanePos",
1560	optFloat,
1561	"view_cells_visualization_clip_plane_pos=",
1562	"0.35");
1563
1564	RegisterOption("ViewCells.Visualization.exportGeometry",
1565	optBool,
1566	"view_cells_visualization_export_geometry=",
1567	"false");
1568
1569	RegisterOption("ViewCells.Visualization.exportRays",
1570	optBool,
1571	"view_cells_visualization_export_rays=",
1572	"false");
1573
1574	RegisterOption("ViewCells.processOnlyValidViewCells",
1575	optBool,
1576	"view_cells_process_only_valid_view_cells",
1577	"false");
1578
1579	RegisterOption("ViewCells.PostProcess.maxCostRatio",
1580	optFloat,
1581	"view_cells_post_process_max_cost_ratio=",
1582	"0.9");
1583
1584	RegisterOption("ViewCells.PostProcess.renderCostWeight",
1585	optFloat,
1586	"view_cells_post_process_render_cost_weight",
1587	"0.5");
1588
1589	RegisterOption("ViewCells.PostProcess.avgCostMaxDeviation",
1590	optFloat,
1591	"view_cells_avgcost_max_deviations",
1592	"0.5");
1593
1594	RegisterOption("ViewCells.PostProcess.maxMergesPerPass",
1595	optInt,
1596	"view_cells_post_process_max_merges_per_pass=",
1597	"500");
1598
1599	RegisterOption("ViewCells.PostProcess.minViewCells",
1600	optInt,
1601	"view_cells_post_process_min_view_cells=",
1602	"1000");
1603
1604	RegisterOption("ViewCells.PostProcess.useRaysForMerge",
1605	optBool,
1606	"view_cells_post_process_use_rays_for_merge=",
1607	"false");
1608
1609	RegisterOption("ViewCells.PostProcess.merge",
1610	optBool,
1611	"view_cells_post_process_merge=",
1612	"true");
1613
1614	RegisterOption("ViewCells.Visualization.exportMergedViewCells",
1615	optBool,
1616	"view_cells_viz_export_merged_viewcells=",
1617	"false");
1618
1619	RegisterOption("ViewCells.maxStaticMemory",
1620	optFloat,
1621	"view_cells_max_static_mem=",
1622	"8.0");
1623
1624	RegisterOption("ViewCells.Visualization.useClipPlane",
1625	optBool,
1626	"view_cells_viz_use_clip_plane=",
1627	"false");
1628
1629	RegisterOption("ViewCells.showVisualization",
1630	optBool,
1631	"view_cells_show_visualization=",
1632	"false");
1633
1634	RegisterOption("ViewCells.Visualization.clipPlaneAxis",
1635	optInt,
1636	"view_cells_viz_clip_plane_axis=",
1637	"0");
1638
1639	RegisterOption("ViewCells.loadGeometry",
1640	optBool,
1641	"view_cells_load_geometry=",
1642	"false");
1643
1644	RegisterOption("ViewCells.geometryFilename",
1645	optString,
1646	"view_cells_geometry_filename=",
1647	"viewCellsGeometry.x3d");
1648
1649	RegisterOption("ViewCells.useBaseTrianglesAsGeometry",
1650	optBool,
1651	"view_cells_use_base_triangles_as_geometry=",
1652	"false");
1653
1654	RegisterOption("ViewCells.compressObjects",
1655	optBool,
1656	"view_cells_compress_objects=",
1657	"false");
1658
1659	RegisterOption("ViewCells.useKdPvs",
1660	optBool,
1661	"view_cells_use_kd_pvs",
1662	"false");
1663
1664	RegisterOption("ViewCells.useKdPvsAfterFiltering",
1665	optBool,
1666	"af_use_kd_pvs",
1667	"false");
1668
1669	RegisterOption("ViewCells.importRandomViewCells",
1670	optBool,
1671	"view_cells_import_random_viewcells=",
1672	"false");
1673
1674	RegisterOption("ViewCells.exportRandomViewCells",
1675	optBool,
1676	"view_cells_export_random_viewcells=",
1677	"false");
1678
1679
1680
1681	/****************************************************************************/
1682	/* Render simulation related options */
1683	/****************************************************************************/
1684
1685
1686	RegisterOption("Simulation.objRenderCost",
1687	optFloat,
1688	"simulation_obj_render_cost",
1689	"1.0");
1690
1691	RegisterOption("Simulation.vcOverhead",
1692	optFloat,
1693	"simulation_vc_overhead",
1694	"0.05");
1695
1696	RegisterOption("Simulation.moveSpeed",
1697	optFloat,
1698	"simulation_moveSpeed",
1699	"1.0");
1700
1701
1702
1703	/******************************************************************/
1704	/* Bsp tree related options */
1705	/******************************************************************/
1706
1707
1708	RegisterOption("BspTree.Construction.input",
1709	optString,
1710	"bsp_construction_input=",
1711	"fromViewCells");
1712
1713	RegisterOption("BspTree.subdivisionStats",
1714	optString,
1715	"bsp_subdivision_stats=",
1716	"bspSubdivisionStats.log");
1717
1718	RegisterOption("BspTree.Construction.samples",
1719	optInt,
1720	"bsp_construction_samples=",
1721	"100000");
1722
1723	RegisterOption("BspTree.Construction.epsilon",
1724	optFloat,
1725	"bsp_construction_epsilon=",
1726	"0.002");
1727
1728	RegisterOption("BspTree.Termination.minPolygons",
1729	optInt,
1730	"bsp_term_min_polygons=",
1731	"5");
1732
1733	RegisterOption("BspTree.Termination.minPvs",
1734	optInt,
1735	"bsp_term_min_pvs=",
1736	"20");
1737
1738	RegisterOption("BspTree.Termination.minProbability",
1739	optFloat,
1740	"bsp_term_min_probability=",
1741	"0.001");
1742
1743	RegisterOption("BspTree.Termination.maxRayContribution",
1744	optFloat,
1745	"bsp_term_ray_contribution=",
1746	"0.005");
1747
1748	RegisterOption("BspTree.Termination.minAccRayLenght",
1749	optFloat,
1750	"bsp_term_min_acc_ray_length=",
1751	"50");
1752
1753	RegisterOption("BspTree.Termination.minRays",
1754	optInt,
1755	"bsp_term_min_rays=",
1756	"-1");
1757
1758	RegisterOption("BspTree.Termination.ct_div_ci",
1759	optFloat,
1760	"bsp_term_ct_div_ci=",
1761	"0.0");
1762
1763	RegisterOption("BspTree.Termination.maxDepth",
1764	optInt,
1765	"bsp_term_max_depth=",
1766	"100");
1767
1768	RegisterOption("BspTree.Termination.maxCostRatio",
1769	optFloat,
1770	"bsp_term_axis_aligned_max_cost_ratio=",
1771	"1.5");
1772
1773	RegisterOption("BspTree.Termination.AxisAligned.ct_div_ci",
1774	optFloat,
1775	"bsp_term_axis_aligned_ct_div_ci=",
1776	"0.5");
1777
1778	RegisterOption("BspTree.AxisAligned.splitBorder",
1779	optFloat,
1780	"bsp__axis_aligned_split_border=",
1781	"0.1");
1782
1783	RegisterOption("BspTree.Termination.AxisAligned.minPolys",
1784	optInt,
1785	"bsp_term_axis_aligned_max_polygons=",
1786	"50");
1787
1788	RegisterOption("BspTree.Termination.AxisAligned.minObjects",
1789	optInt,
1790	"bsp_term_min_objects=",
1791	"3");
1792
1793	RegisterOption("BspTree.Termination.AxisAligned.minRays",
1794	optInt,
1795	"bsp_term_axis_aligned_min_rays=",
1796	"-1");
1797
1798	RegisterOption("BspTree.splitPlaneStrategy",
1799	optString,
1800	"bsp_split_method=",
1801	"leastSplits");
1802
1803	RegisterOption("BspTree.maxPolyCandidates",
1804	optInt,
1805	"bsp_max_poly_candidates=",
1806	"20");
1807
1808	RegisterOption("BspTree.maxRayCandidates",
1809	optInt,
1810	"bsp_max_plane_candidates=",
1811	"20");
1812
1813	RegisterOption("BspTree.maxTests",
1814	optInt,
1815	"bsp_max_tests=",
1816	"5000");
1817
1818	RegisterOption("BspTree.Termination.maxViewCells",
1819	optInt,
1820	"bsp_max_view_cells=",
1821	"5000");
1822
1823	RegisterOption("BspTree.Visualization.exportSplits",
1824	optBool,
1825	"bsp_visualization.export_splits=",
1826	"false");
1827
1828	RegisterOption("BspTree.Factor.verticalSplits", optFloat, "bsp_factor_vertical=", "1.0");
1829	RegisterOption("BspTree.Factor.largestPolyArea", optFloat, "bsp_factor_largest_poly=", "1.0");
1830	RegisterOption("BspTree.Factor.blockedRays", optFloat, "bsp_factor_blocked=", "1.0");
1831	RegisterOption("BspTree.Factor.leastSplits", optFloat, "bsp_factor_least_splits=", "1.0");
1832	RegisterOption("BspTree.Factor.balancedPolys", optFloat, "bsp_factor_balanced_polys=", "1.0");
1833	RegisterOption("BspTree.Factor.balancedViewCells", optFloat, "bsp_factor_balanced_view_cells=", "1.0");
1834	RegisterOption("BspTree.Factor.leastRaySplits", optFloat, "bsp_factor_least_ray_splits=", "1.0");
1835	RegisterOption("BspTree.Factor.balancedRays", optFloat, "bsp_factor_balanced_rays=", "1.0");
1836	RegisterOption("BspTree.Factor.pvs", optFloat, "bsp_factor_pvs=", "1.0");
1837
1838
1839
1840
1841	/**********************************************************************/
1842	/* Preprocessor related options */
1843	/**********************************************************************/
1844
1845	RegisterOption("Preprocessor.type",
1846	optString,
1847	"preprocessor=",
1848	"sampling");
1849
1850	RegisterOption("Preprocessor.stats",
1851	optString,
1852	"preprocessor_stats=",
1853	"stats.log");
1854
1855	RegisterOption("Preprocessor.samplesFilename",
1856	optString,
1857	"preprocessor_samples_filename=",
1858	"rays.out");
1859
1860	RegisterOption("Preprocessor.loadMeshes",
1861	optBool,
1862	"preprocessor_load_meshes",
1863	"true");
1864
1865	RegisterOption("Preprocessor.evaluateFilter",
1866	optBool,
1867	"preprocessor_evaluate_filter",
1868	"false");
1869
1870	RegisterOption("Preprocessor.delayVisibilityComputation",
1871	optBool,
1872	"preprocessor_delay_computation",
1873	"true");
1874
1875	RegisterOption("Preprocessor.pvsRenderErrorSamples",
1876	optInt,
1877	"preprocessor_pvs_rendererror_samples=",
1878	"10000");
1879
1880	RegisterOption("Preprocessor.useGlRenderer",
1881	optBool,
1882	"preprocessor_use_gl_renderer",
1883	"false");
1884
1885	RegisterOption("Preprocessor.useGlDebugger",
1886	optBool,
1887	"preprocessor_use_gl_debugger",
1888	"false");
1889
1890	RegisterOption("Preprocessor.detectEmptyViewSpace",
1891	optBool,
1892	"preprocessor_detect_empty_viewspace",
1893	"false");
1894
1895	RegisterOption("Preprocessor.quitOnFinish",
1896	optBool,
1897	"preprocessor_quit_on_finish",
1898	"true");
1899
1900	RegisterOption("Preprocessor.computeVisibility",
1901	optBool,
1902	"preprocessor_compute_visibility",
1903	"true");
1904
1905	RegisterOption("Preprocessor.exportVisibility",
1906	optBool,
1907	"preprocessor_export_visibility",
1908	"true");
1909
1910	RegisterOption("Preprocessor.visibilityFile",
1911	optString,
1912	"preprocessor_visibility_file=",
1913	"visibility.xml");
1914
1915	RegisterOption("Preprocessor.applyVisibilityFilter",
1916	optBool,
1917	"preprocessor_apply_filter",
1918	"false");
1919
1920	RegisterOption("Preprocessor.evaluatePixelError",
1921	optBool,
1922	"preprocessor_evaluatePixelError",
1923	"false");
1924
1925	RegisterOption("Preprocessor.applyVisibilitySpatialFilter",
1926	optBool,
1927	"preprocessor_apply_spatial_filter",
1928	"false");
1929
1930	RegisterOption("Preprocessor.visibilityFilterWidth",
1931	optFloat,
1932	"preprocessor_visibility_filter_width=",
1933	"0.02");
1934
1935	RegisterOption("Preprocessor.histogram.maxValue",
1936	optInt,
1937	"preprocessor_histogram_max_value=",
1938	"1000");
1939
1940	RegisterOption("Preprocessor.rayCastMethod",
1941	optInt,
1942	"preprocessor_ray_cast_method=",
1943	"0");
1944
1945	RegisterOption("Preprocessor.histogram.intervals",
1946	optInt,
1947	"preprocessor_histogram_intervals=",
1948	"20");
1949
1950	RegisterOption("Preprocessor.histogram.file",
1951	optString,
1952	"preprocessor_histogram_file=",
1953	"histogram.log");
1954
1955	RegisterOption("Preprocessor.exportKdTree",
1956	optBool,
1957	"preprocessor_export_kd_tree=",
1958	"false");
1959
1960	RegisterOption("Preprocessor.loadKdTree",
1961	optBool,
1962	"preprocessor_load_kd_tree=",
1963	"false");
1964
1965	RegisterOption("Preprocessor.kdTreeFilename",
1966	optString,
1967	"preprocessor_kd_tree_filename=",
1968	"vienna_kdtree.bin.gz");
1969
1970	RegisterOption("Preprocessor.exportObj",
1971	optBool,
1972	"preprocessor_export_obj=",
1973	"false");
1974
1975	RegisterOption("Preprocessor.useViewSpaceBox",
1976	optBool,
1977	"preprocessor_use_viewspace_box=",
1978	"false");
1979
1980	RegisterOption("Preprocessor.Export.rays", optBool, "export_rays", "false");
1981	RegisterOption("Preprocessor.Export.animation", optBool, "export_animation", "false");
1982	RegisterOption("Preprocessor.Export.numRays", optInt, "export_num_rays=", "5000");
1983
1984	/*************************************************************************/
1985	/* VSS Preprocessor cells related options */
1986	/*************************************************************************/
1987
1988	RegisterOption("VssTree.maxDepth", optInt, "kd_depth=", "12");
1989	RegisterOption("VssTree.minPvs", optInt, "kd_minpvs=", "1");
1990	RegisterOption("VssTree.minRays", optInt, "kd_minrays=", "10");
1991	RegisterOption("VssTree.maxCostRatio", optFloat, "maxcost=", "0.95");
1992	RegisterOption("VssTree.maxRayContribution", optFloat, "maxraycontrib=", "0.5");
1993
1994	RegisterOption("VssTree.epsilon", optFloat, "kd_eps=", "1e-6");
1995	RegisterOption("VssTree.ct_div_ci", optFloat, "kd_ctdivci=", "1.0");
1996	RegisterOption("VssTree.randomize", optBool, "randomize", "false");
1997	RegisterOption("VssTree.splitType", optString, "split=", "queries");
1998	RegisterOption("VssTree.splitUseOnlyDrivingAxis", optBool, "splitdriving=", "false");
1999	RegisterOption("VssTree.useRss", optBool, "rss=", "false");
2000	RegisterOption("VssTree.numberOfEndPointDomains", optInt, "endpoints=", "10000");
2001
2002	RegisterOption("VssTree.minSize", optFloat, "minsize=", "0.001");
2003
2004	RegisterOption("VssTree.maxTotalMemory", optFloat, "mem=", "60.0");
2005	RegisterOption("VssTree.maxStaticMemory", optFloat, "statmem=", "8.0");
2006
2007	RegisterOption("VssTree.queryType", optString, "qtype=", "static");
2008
2009
2010
2011	RegisterOption("VssTree.queryPosWeight", optFloat, "qposweight=", "0.0");
2012	RegisterOption("VssTree.useRefDirSplits", optBool, "refdir=", "false");
2013	RegisterOption("VssTree.refDirAngle", optFloat, "refangle=", "10");
2014	RegisterOption("VssTree.refDirBoxMaxSize", optFloat, "refboxsize=", "0.1");
2015	RegisterOption("VssTree.accessTimeThreshold", optInt, "accesstime=", "1000");
2016	RegisterOption("VssTree.minCollapseDepth", optInt, "colldepth=", "4");
2017
2018	RegisterOption("VssTree.interleaveDirSplits", optBool, "interleavedirsplits", "true");
2019	RegisterOption("VssTree.dirSplitDepth", optInt, "dirsplidepth=", "10");
2020
2021
2022	// RegisterOption("RssPreprocessor.initialSamples",
2023	// optInt,
2024	// "rss_initial_samples=",
2025	// "100000");
2026
2027	// RegisterOption("RssPreprocessor.vssSamples",
2028	// optInt,
2029	// "rss_vss_samples=",
2030	// "1000000");
2031
2032	// RegisterOption("RssPreprocessor.vssSamplesPerPass",
2033	// optInt,
2034	// "rss_vss_samples_per_pass=",
2035	// "1000");
2036
2037	// RegisterOption("RssPreprocessor.samplesPerPass",
2038	// optInt,
2039	// "rss_samples_per_pass=",
2040	// "100000");
2041
2042	RegisterOption("RssPreprocessor.useImportanceSampling",
2043	optBool,
2044	"rss_use_importance",
2045	"true");
2046
2047	RegisterOption("RssPreprocessor.useRssTree",
2048	optBool,
2049	"rss_use_rss_tree",
2050	"true");
2051
2052	RegisterOption("RssPreprocessor.objectBasedSampling",
2053	optBool,
2054	"rss_object_based_sampling",
2055	"true");
2056
2057	RegisterOption("RssPreprocessor.directionalSampling",
2058	optBool,
2059	"rss_directional_sampling",
2060	"false");
2061
2062	RegisterOption("RssPreprocessor.distributions",
2063	optString,
2064	"rss_distributions=",
2065	"rss+spatial+object");
2066
2067	RegisterOption("RssTree.hybridDepth", optInt, "hybrid_depth=", "10");
2068	RegisterOption("RssTree.maxDepth", optInt, "kd_depth=", "12");
2069	RegisterOption("RssTree.minPvs", optInt, "kd_minpvs=", "1");
2070	RegisterOption("RssTree.minRays", optInt, "kd_minrays=", "10");
2071	RegisterOption("RssTree.maxCostRatio", optFloat, "maxcost=", "0.95");
2072	RegisterOption("RssTree.maxRayContribution", optFloat, "maxraycontrib=", "0.5");
2073
2074	RegisterOption("RssTree.epsilon", optFloat, "kd_eps=", "1e-6");
2075	RegisterOption("RssTree.ct_div_ci", optFloat, "kd_ctdivci=", "1.0");
2076	RegisterOption("RssTree.randomize", optBool, "randomize=", "false");
2077	RegisterOption("RssTree.splitType", optString, "rss_split=", "queries");
2078	RegisterOption("RssTree.splitUseOnlyDrivingAxis", optBool, "splitdriving=", "false");
2079
2080	RegisterOption("RssTree.numberOfEndPointDomains", optInt, "endpoints=", "10000");
2081
2082	RegisterOption("RssTree.minSize", optFloat, "minsize=", "0.001");
2083
2084	RegisterOption("RssTree.maxTotalMemory", optFloat, "mem=", "60.0");
2085	RegisterOption("RssTree.maxStaticMemory", optFloat, "statmem=", "8.0");
2086
2087	RegisterOption("RssTree.queryType", optString, "qtype=", "static");
2088
2089	RegisterOption("RssTree.queryPosWeight", optFloat, "qposweight=", "0.0");
2090	RegisterOption("RssTree.useRefDirSplits", optBool, "refdir", "false");
2091	RegisterOption("RssTree.refDirAngle", optFloat, "refangle=", "10");
2092	RegisterOption("RssTree.refDirBoxMaxSize", optFloat, "refboxsize=", "0.1");
2093	RegisterOption("RssTree.accessTimeThreshold", optInt, "accesstime=", "1000");
2094	RegisterOption("RssTree.minCollapseDepth", optInt, "colldepth=", "4");
2095
2096	RegisterOption("RssTree.interleaveDirSplits", optBool, "interleavedirsplits=", "true");
2097	RegisterOption("RssTree.dirSplitDepth", optInt, "dirsplidepth=", "10");
2098	RegisterOption("RssTree.importanceBasedCost", optBool, "importance_based_cost=", "true");
2099	RegisterOption("RssTree.maxRays", optInt, "rss_max_rays=", "2000000");
2100
2101	RegisterOption("RssTree.perObjectTree", optBool, "rss_per_object_tree", "false");
2102
2103	RegisterOption("RssPreprocessor.Export.pvs", optBool, "rss_export_pvs=", "false");
2104	RegisterOption("RssPreprocessor.Export.rssTree", optBool, "rss_export_rss_tree=", "false");
2105
2106	RegisterOption("RssPreprocessor.useViewcells", optBool, "rss_use_viewcells=", "false");
2107	RegisterOption("RssPreprocessor.updateSubdivision",
2108	optBool,
2109	"rss_update_subdivision=",
2110	"false");
2111
2112
2113	/************************************************************************************/
2114	/* Rss preprocessor related options */
2115	/************************************************************************************/
2116
2117
2118	RegisterOption("RssPreprocessor.loadInitialSamples",
2119	optBool,
2120	"vss_load_loadInitialSamples=",
2121	"false");
2122
2123	RegisterOption("RssPreprocessor.storeInitialSamples",
2124	optBool,
2125	"vss_store_storeInitialSamples=",
2126	"false");
2127
2128
2129	/************************************************************************************/
2130	/* View space partition BSP tree related options */
2131	/************************************************************************************/
2132
2133	RegisterOption("VspBspTree.Termination.minGlobalCostRatio",
2134	optFloat,
2135	"vsp_bsp_term_min_global_cost_ratio=",
2136	"0.0001");
2137
2138	RegisterOption("VspBspTree.useSplitCostQueue",
2139	optBool,
2140	"vsp_bsp_use_split_cost_queue=",
2141	"true");
2142
2143	RegisterOption("VspBspTree.Termination.globalCostMissTolerance",
2144	optInt,
2145	"vsp_bsp_term_global_cost_miss_tolerance=",
2146	"4");
2147
2148	RegisterOption("VspBspTree.Termination.minPolygons",
2149	optInt,
2150	"vsp_bsp_term_min_polygons=",
2151	"-1");
2152
2153	RegisterOption("VspBspTree.Termination.minPvs",
2154	optInt,
2155	"vsp_bsp_term_min_pvs=",
2156	"20");
2157
2158	RegisterOption("VspBspTree.Termination.minProbability",
2159	optFloat,
2160	"vsp_bsp_term_min_probability=",
2161	"0.001");
2162
2163	RegisterOption("VspBspTree.subdivisionStats",
2164	optString,
2165	"vsp_bsp_subdivision_stats=",
2166	"vspBspSubdivisionStats.log");
2167
2168	RegisterOption("VspBspTree.Termination.maxRayContribution",
2169	optFloat,
2170	"vsp_bsp_term_ray_contribution=",
2171	"2");
2172
2173	RegisterOption("VspBspTree.Termination.minAccRayLenght",
2174	optFloat,
2175	"vsp_bsp_term_min_acc_ray_length=",
2176	"50");
2177
2178	RegisterOption("VspBspTree.Termination.minRays",
2179	optInt,
2180	"vsp_bsp_term_min_rays=",
2181	"-1");
2182
2183	RegisterOption("VspBspTree.Termination.ct_div_ci",
2184	optFloat,
2185	"vsp_bsp_term_ct_div_ci=",
2186	"0.0");
2187
2188	RegisterOption("VspBspTree.Termination.maxDepth",
2189	optInt,
2190	"vsp_bsp_term_max_depth=",
2191	"50");
2192
2193	RegisterOption("VspBspTree.Termination.AxisAligned.maxCostRatio",
2194	optFloat,
2195	"vsp_bsp_term_axis_aligned_max_cost_ratio=",
2196	"1.5");
2197
2198	RegisterOption("VspBspTree.useCostHeuristics",
2199	optBool,
2200	"vsp_bsp_use_cost_heuristics=",
2201	"false");
2202
2203	RegisterOption("VspBspTree.Termination.maxViewCells",
2204	optInt,
2205	"vsp_bsp_term_max_view_cells=",
2206	"10000");
2207
2208	RegisterOption("VspBspTree.Termination.maxCostRatio",
2209	optFloat,
2210	"vsp_bsp_term_max_cost_ratio=",
2211	"1.5");
2212
2213	RegisterOption("VspBspTree.Termination.missTolerance",
2214	optInt,
2215	"vsp_bsp_term_miss_tolerance=",
2216	"4");
2217
2218	RegisterOption("VspBspTree.splitPlaneStrategy",
2219	optInt,
2220	"vsp_bsp_split_method=",
2221	"1026");
2222
2223	RegisterOption("VspBspTree.maxPolyCandidates",
2224	optInt,
2225	"vsp_bsp_max_poly_candidates=",
2226	"20");
2227
2228	RegisterOption("VspBspTree.maxRayCandidates",
2229	optInt,
2230	"vsp_bsp_max_plane_candidates=",
2231	"20");
2232
2233	RegisterOption("VspBspTree.maxTests",
2234	optInt,
2235	"vsp_bsp_max_tests=",
2236	"5000");
2237
2238	RegisterOption("VspBspTree.Construction.samples",
2239	optInt,
2240	"vsp_bsp_construction_samples=",
2241	"100000");
2242
2243	RegisterOption("VspBspTree.Construction.minBand",
2244	optFloat,
2245	"vsp_bsp_construction_min_band=",
2246	"0.01");
2247
2248	RegisterOption("VspBspTree.Construction.maxBand",
2249	optFloat,
2250	"vsp_bsp_construction_max_band=",
2251	"0.99");
2252
2253	RegisterOption("VspBspTree.Construction.useDrivingAxisForMaxCost",
2254	optBool,
2255	"vsp_bsp_construction_use_drivingaxis_for_maxcost=",
2256	"false");
2257
2258	RegisterOption("VspBspTree.Construction.epsilon",
2259	optFloat,
2260	"vsp_bsp_construction_epsilon=",
2261	"0.002");
2262
2263	RegisterOption("VspBspTree.Visualization.exportSplits",
2264	optBool,
2265	"vsp_bsp_visualization.export_splits",
2266	"false");
2267
2268	RegisterOption("VspBspTree.splitUseOnlyDrivingAxis",
2269	optBool,
2270	"vsp_bsp_split_only_driving_axis=",
2271	"false");
2272
2273	RegisterOption("VspBspTree.usePolygonSplitIfAvailable",
2274	optBool,
2275	"vsp_bsp_usePolygonSplitIfAvailable=",
2276	"false");
2277
2278	RegisterOption("VspBspTree.Termination.AxisAligned.minRays",
2279	optInt,
2280	"bsp_term_axis_aligned_min_rays=",
2281	"0");
2282
2283	RegisterOption("VspBspTree.Termination.AxisAligned.maxRayContribution",
2284	optFloat,
2285	"bsp_term_axis_aligned_min_rays=",
2286	"2");
2287
2288	RegisterOption("VspBspTree.Factor.leastRaySplits",
2289	optFloat,
2290	"vsp_bsp_factor_least_ray_splits=",
2291	"1.0");
2292
2293	RegisterOption("VspBspTree.Factor.balancedRays",
2294	optFloat,
2295	"vsp_bsp_factor_balanced_rays=",
2296	"1.0");
2297
2298	RegisterOption("VspBspTree.Factor.pvs",
2299	optFloat,
2300	"vsp_bsp_factor_pvs=",
2301	"1.0");
2302
2303	RegisterOption("VspBspTree.Construction.renderCostWeight",
2304	optFloat,
2305	"vsp_bsp_post_process_render_cost_weight=",
2306	"1.0");
2307
2308	RegisterOption("VspBspTree.Construction.renderCostDecreaseWeight",
2309	optFloat,
2310	"vsp_bsp_construction_render_cost_decrease_weight=",
2311	"0.99");
2312
2313	RegisterOption("VspBspTree.Construction.randomize",
2314	optBool,
2315	"vsp_bsp_construction_randomize=",
2316	"false");
2317
2318	RegisterOption("VspBspTree.simulateOctree",
2319	optBool,
2320	"vsp_bsp_simulate_octree=",
2321	"false");
2322
2323	RegisterOption("VspBspTree.nodePriorityQueueType",
2324	optInt,
2325	"vsp_bsp_node_queue_type=",
2326	"0");
2327
2328	RegisterOption("VspBspTree.useRandomAxis",
2329	optBool,
2330	"-vsp_bsp_use_random_axis=",
2331	"false");
2332
2333	RegisterOption("VspBspTree.maxTotalMemory",
2334	optFloat,
2335	"vsp_bsp_max_total_mem=",
2336	"60.0");
2337
2338	RegisterOption("VspBspTree.maxStaticMemory",
2339	optFloat,
2340	"vsp_bsp_max_static_mem=",
2341	"8.0");
2342
2343
2344
2345	/***************************************************************************/
2346	/* View space partition tree related options */
2347	/***************************************************************************/
2348
2349
2350	RegisterOption("VspTree.Construction.samples",
2351	optInt,
2352	"vsp_construction_samples=",
2353	"10000");
2354
2355	RegisterOption("VspTree.Construction.renderCostDecreaseWeight",
2356	optFloat,
2357	"vsp_construction_render_cost_decrease_weight=",
2358	"0.99");
2359
2360	RegisterOption("VspTree.Termination.maxDepth",
2361	optInt,
2362	"vsp_term_max_depth=",
2363	"100");
2364
2365	RegisterOption("VspTree.Termination.minRays",
2366	optInt,
2367	"vsp_term_min_rays=",
2368	"-1");
2369
2370
2371	RegisterOption("VspTree.Termination.minPvs",
2372	optInt,
2373	"vsp_term_min_pvs=",
2374	"20");
2375
2376	RegisterOption("VspTree.Termination.minProbability",
2377	optFloat,
2378	"vsp_term_min_probability=",
2379	"0.0000001");
2380
2381	RegisterOption("VspTree.Termination.maxRayContribution",
2382	optFloat,
2383	"vsp_term_ray_contribution=",
2384	"0.9");
2385
2386	RegisterOption("VspTree.Termination.maxCostRatio",
2387	optFloat,
2388	"vsp_term_max_cost_ratio=",
2389	"1.5");
2390
2391	RegisterOption("VspTree.Termination.maxViewCells",
2392	optInt,
2393	"vsp_term_max_view_cells=",
2394	"10000");
2395
2396	RegisterOption("VspTree.Termination.missTolerance",
2397	optInt,
2398	"vsp_term_miss_tolerance=",
2399	"4");
2400
2401	RegisterOption("VspTree.Termination.minGlobalCostRatio",
2402	optFloat,
2403	"vsp_term_min_global_cost_ratio=",
2404	"0.0001");
2405
2406	RegisterOption("VspTree.Termination.globalCostMissTolerance",
2407	optInt,
2408	"vsp_term_global_cost_miss_tolerance=",
2409	"4");
2410
2411	RegisterOption("VspTree.Termination.ct_div_ci",
2412	optFloat,
2413	"vsp_term_ct_div_ci=",
2414	"0.0");
2415
2416	RegisterOption("VspTree.Construction.epsilon",
2417	optFloat,
2418	"vsp_construction_epsilon=",
2419	"0.002");
2420
2421	RegisterOption("VspTree.splitUseOnlyDrivingAxis",
2422	optBool,
2423	"vsp_split_only_driving_axis=",
2424	"false");
2425
2426	RegisterOption("VspTree.maxStaticMemory",
2427	optFloat,
2428	"vsp_max_static_mem=",
2429	"8.0");
2430
2431	RegisterOption("VspTree.useCostHeuristics",
2432	optBool,
2433	"vsp_use_cost_heuristics=",
2434	"false");
2435
2436	RegisterOption("VspTree.simulateOctree",
2437	optBool,
2438	"vsp_simulate_octree=",
2439	"false");
2440
2441	RegisterOption("VspTree.Construction.randomize",
2442	optBool,
2443	"vsp_construction_randomize=",
2444	"false");
2445
2446	RegisterOption("VspTree.subdivisionStats",
2447	optString,
2448	"vsp_subdivision_stats=",
2449	"vspSubdivisionStats.log");
2450
2451	RegisterOption("VspTree.Construction.minBand",
2452	optFloat,
2453	"vsp_construction_min_band=",
2454	"0.01");
2455
2456	RegisterOption("VspTree.Construction.maxBand",
2457	optFloat,
2458	"vsp_construction_max_band=",
2459	"0.99");
2460
2461	RegisterOption("VspTree.maxTests",
2462	optInt,
2463	"vsp_max_tests=",
2464	"5000");
2465
2466
2467
2468	/***********************************************************************/
2469	/* Object space partition tree related options */
2470	/***********************************************************************/
2471
2472
2473	RegisterOption("OspTree.Construction.randomize",
2474	optBool,
2475	"osp_construction_randomize=",
2476	"false");
2477
2478	RegisterOption("OspTree.Termination.maxDepth",
2479	optInt,
2480	"osp_term_max_depth=",
2481	"30");
2482
2483	RegisterOption("OspTree.Termination.maxLeaves",
2484	optInt,
2485	"osp_term_max_leaves=",
2486	"1000");
2487
2488	RegisterOption("OspTree.Termination.minObjects",
2489	optInt,
2490	"osp_term_min_objects=",
2491	"1");
2492
2493	RegisterOption("OspTree.Termination.minProbability",
2494	optFloat,
2495	"osp_term_min_objects=",
2496	"0.00001");
2497
2498	RegisterOption("OspTree.Termination.missTolerance",
2499	optInt,
2500	"osp_term_miss_tolerance=",
2501	"8");
2502
2503	RegisterOption("OspTree.Termination.maxCostRatio",
2504	optFloat,
2505	"osp_term_max_cost_ratio=",
2506	"0.99");
2507
2508	RegisterOption("OspTree.Termination.minGlobalCostRatio",
2509	optFloat,
2510	"osp_term_min_global_cost_ratio=",
2511	"0.00001");
2512
2513	RegisterOption("OspTree.Termination.globalCostMissTolerance",
2514	optInt,
2515	"osp_term_global_cost_miss_tolerance=",
2516	"4");
2517
2518	RegisterOption("OspTree.Termination.ct_div_ci",
2519	optFloat,
2520	"osp_term_ct_div_ci=",
2521	"0");
2522
2523	RegisterOption("OspTree.Construction.epsilon",
2524	optFloat,
2525	"osp_construction_epsilon=",
2526	"0.00001");
2527
2528	// if only the driving axis is used for axis aligned split
2529	RegisterOption("OspTree.splitUseOnlyDrivingAxis",
2530	optBool,
2531	"osp_split_only_driving_axis=",
2532	"false");
2533
2534	RegisterOption("OspTree.maxStaticMemory",
2535	optFloat,
2536	"osp_max_static_mem=",
2537	"8.0");
2538
2539	RegisterOption("OspTree.useCostHeuristics",
2540	optBool,
2541	"osp_use_cost_heuristics=",
2542	"true");
2543
2544	RegisterOption("OspTree.subdivisionStats",
2545	optString,
2546	"osp_subdivision_stats=",
2547	"ospSubdivisionStats.log");
2548
2549	RegisterOption("OspTree.Construction.splitBorder",
2550	optFloat,
2551	"osp_construction_split_border=",
2552	"0.01");
2553
2554	RegisterOption("OspTree.Construction.renderCostDecreaseWeight",
2555	optFloat,
2556	"osp_construction_render_cost_decrease_weight=",
2557	"0.99");
2558
2559
2560
2561	/**********************************************************************/
2562	/* Bounding Volume Hierarchy related options */
2563	/**********************************************************************/
2564
2565	RegisterOption("BvHierarchy.Construction.randomize",
2566	optBool,
2567	"bvh_construction_randomize=",
2568	"false");
2569
2570	RegisterOption("BvHierarchy.Termination.maxDepth",
2571	optInt,
2572	"bvh_term_max_depth=",
2573	"30");
2574
2575	RegisterOption("BvHierarchy.Termination.maxLeaves",
2576	optInt,
2577	"bvh_term_max_leaves=",
2578	"1000");
2579
2580	RegisterOption("BvHierarchy.Termination.minObjects",
2581	optInt,
2582	"bvh_term_min_objects=",
2583	"1");
2584
2585	RegisterOption("BvHierarchy.Termination.minProbability",
2586	optFloat,
2587	"bvh_term_min_objects=",
2588	"0.0000001");
2589
2590	RegisterOption("BvHierarchy.Termination.minRays",
2591	optInt,
2592	"bvh_term_min_rays=",
2593	"0");
2594
2595	RegisterOption("BvHierarchy.Termination.missTolerance",
2596	optInt,
2597	"osp_term_miss_tolerance=",
2598	"8");
2599
2600	RegisterOption("BvHierarchy.Termination.maxCostRatio",
2601	optFloat,
2602	"bvh_term_max_cost_ratio=",
2603	"0.99");
2604
2605	RegisterOption("BvHierarchy.Termination.minGlobalCostRatio",
2606	optFloat,
2607	"bvh_term_min_global_cost_ratio=",
2608	"0.00001");
2609
2610	RegisterOption("BvHierarchy.Termination.globalCostMissTolerance",
2611	optInt,
2612	"bvh_term_global_cost_miss_tolerance=",
2613	"4");
2614
2615	// if only the driving axis is used for axis aligned split
2616	RegisterOption("BvHierarchy.splitUseOnlyDrivingAxis",
2617	optBool,
2618	"bvh_split_only_driving_axis=",
2619	"false");
2620
2621	RegisterOption("BvHierarchy.maxStaticMemory",
2622	optFloat,
2623	"bvh_max_static_mem=",
2624	"8.0");
2625
2626	RegisterOption("BvHierarchy.useCostHeuristics",
2627	optBool,
2628	"bvh_use_cost_heuristics=",
2629	"true");
2630
2631	RegisterOption("BvHierarchy.useSah",
2632	optBool,
2633	"bvh_use_sah=",
2634	"false");
2635
2636	RegisterOption("BvHierarchy.subdivisionStats",
2637	optString,
2638	"bvh_subdivision_stats=",
2639	"bvhSubdivisionStats.log");
2640
2641	RegisterOption("BvHierarchy.Construction.renderCostDecreaseWeight",
2642	optFloat,
2643	"bvh_construction_render_cost_decrease_weight=",
2644	"0.99");
2645
2646	RegisterOption("BvHierarchy.Construction.useGlobalSorting",
2647	optBool,
2648	"bvh_construction_use_global_sorting=",
2649	"true");
2650
2651	RegisterOption("BvHierarchy.Construction.useInitialSubdivision",
2652	optBool,
2653	"bvh_construction_use_initial_subdivision=",
2654	"false");
2655
2656	RegisterOption("BvHierarchy.Construction.Initial.minObjects",
2657	optInt,
2658	"bvh_construction_use_initial_min_objects=",
2659	"100000");
2660
2661	RegisterOption("BvHierarchy.Construction.Initial.minArea",
2662	optFloat,
2663	"bvh_construction_use_initial_min_area=",
2664	"0.0001");
2665
2666	RegisterOption("BvHierarchy.Construction.Initial.maxAreaRatio",
2667	optFloat,
2668	"bvh_construction_use_initial_max_area_ratio=",
2669	"0.9");
2670
2671	RegisterOption("BvHierarchy.minRaysForVisibility",
2672	optInt,
2673	"bvh_min_rays_for_vis=",
2674	"0");
2675
2676	RegisterOption("BvHierarchy.maxTests",
2677	optInt,
2678	"bvh_max_tests=",
2679	"50000");
2680
2681
2682	/*******************************************************************/
2683	/* Hierarchy Manager related options */
2684	/*******************************************************************/
2685
2686	RegisterOption("Hierarchy.Construction.samples",
2687	optInt,
2688	"hierarchy_construction_samples=",
2689	"100000");
2690
2691	RegisterOption("Hierarchy.minRenderCost",
2692	optFloat,
2693	"hierarchy_minRenderCost=",
2694	"0");
2695
2696	RegisterOption("Hierarchy.subdivisionStats",
2697	optString,
2698	"hierarchy_subdivision_stats=",
2699	"hierarchySubdivisionStats.log");
2700
2701	RegisterOption("Hierarchy.type",
2702	optString,
2703	"hierarchy_type=",
2704	"bvh");
2705
2706	RegisterOption("Hierarchy.Termination.minGlobalCostRatio",
2707	optFloat,
2708	"hierarchy_term_min_global_cost_ratio=",
2709	"0.000000001");
2710
2711	RegisterOption("Hierarchy.Termination.globalCostMissTolerance",
2712	optInt,
2713	"hierarchy_term_global_cost_miss_tolerance=",
2714	"4");
2715
2716	RegisterOption("Hierarchy.Termination.maxLeaves",
2717	optInt,
2718	"hierarchy_term_max_leaves=",
2719	"1000");
2720
2721	RegisterOption("Hierarchy.Construction.type",
2722	optInt,
2723	"hierarchy_construction_type=",
2724	"0");
2725
2726	RegisterOption("Hierarchy.Construction.minDepthForOsp",
2727	optInt,
2728	"hierarchy_construction_min_depth_for_osp=",
2729	"-1");
2730
2731	RegisterOption("Hierarchy.Construction.startWithObjectSpace",
2732	optBool,
2733	"hierarchy_construction_start_with_osp=",
2734	"true");
2735
2736	RegisterOption("Hierarchy.Construction.considerMemory",
2737	optBool,
2738	"hierarchy_construction_consider_memory=",
2739	"true");
2740
2741	RegisterOption("Hierarchy.Construction.repairQueue",
2742	optBool,
2743	"hierarchy_construction_repair_queue=",
2744	"true");
2745
2746	RegisterOption("Hierarchy.Construction.minDepthForVsp",
2747	optInt,
2748	"hierarchy_construction_min_depth_for_vsp=",
2749	"-1");
2750
2751	RegisterOption("Hierarchy.Termination.maxMemory",
2752	optFloat,
2753	"hierarchy_term_max_memory=",
2754	"1");
2755
2756	RegisterOption("Hierarchy.Termination.memoryConst",
2757	optFloat,
2758	"hierarchy_term_memory_const=",
2759	"1.0");
2760
2761	RegisterOption("Hierarchy.Construction.useMultiLevel",
2762	optBool,
2763	"hierarchy_construction_multilevel=",
2764	"false");
2765
2766	RegisterOption("Hierarchy.Construction.levels",
2767	optInt,
2768	"hierarchy_construction_levels=",
2769	"4");
2770
2771	RegisterOption("Hierarchy.Construction.maxRepairs",
2772	optInt,
2773	"hierarchy_construction_max_repairs=",
2774	"1000");
2775
2776	RegisterOption("Hierarchy.Construction.minStepsOfSameType",
2777	optInt,
2778	"hierarchy_construction_min_steps_same_type=",
2779	"200");
2780
2781	RegisterOption("Hierarchy.Construction.maxStepsOfSameType",
2782	optInt,
2783	"hierarchy_construction_max_steps_same_type=",
2784	"700");
2785
2786	RegisterOption("Hierarchy.Construction.recomputeSplitPlaneOnRepair",
2787	optBool,
2788	"hierarchy_construction_recompute_split_on_repair=",
2789	"true");
2790
2791	RegisterOption("Hierarchy.Construction.maxAvgRaysPerObject",
2792	optFloat,
2793	"hierarchy_construction_max_avg_rays_per_object=",
2794	"0");
2795
2796	RegisterOption("Hierarchy.Construction.minAvgRaysPerObject",
2797	optFloat,
2798	"hierarchy_construction_min_avg_rays_per_object=",
2799	"0");
2800
2801	RegisterOption("Hierarchy.useTraversalTree",
2802	optBool,
2803	"hierarchy_use_traversal_tree=",
2804	"false");
2805
2806	///////////////////////////////////////////////////////
2807
2808	RegisterOption("TraversalTree.Termination.minCost",
2809	optInt,
2810	"kd_term_min_cost=",
2811	"1");
2812
2813	RegisterOption("TraversalTree.Termination.maxNodes",
2814	optInt,
2815	"kd_term_max_nodes=",
2816	"200000");
2817
2818	RegisterOption("TraversalTree.Termination.maxDepth",
2819	optInt,
2820	"kd_term_max_depth=",
2821	"20");
2822
2823	RegisterOption("TraversalTree.Termination.maxCostRatio",
2824	optFloat,
2825	"kd_term_max_cost_ratio=",
2826	"1.5");
2827
2828	RegisterOption("TraversalTree.Termination.ct_div_ci",
2829	optFloat,
2830	"kd_term_ct_div_ci=",
2831	"1.0");
2832
2833	RegisterOption("TraversalTree.splitMethod",
2834	optString,
2835	"kd_split_method=",
2836	"spatialMedian");
2837
2838	RegisterOption("TraversalTree.splitBorder",
2839	optFloat,
2840	"kd_split_border=",
2841	"0.1");
2842
2843	RegisterOption("TraversalTree.sahUseFaces",
2844	optBool,
2845	"kd_sah_use_faces=",
2846	"true");
2847
2848	/////////////////////////////////////////////////////////////////
2849
2850	}
2851
2852	void
2853	Environment::SetStaticOptions()
2854	{
2855
2856	// get Global option values
2857	GetRealValue("Limits.threshold", Limits::Threshold);
2858	GetRealValue("Limits.small", Limits::Small);
2859	GetRealValue("Limits.infinity", Limits::Infinity);
2860
2861
2862	}
2863
2864	bool
2865	Environment::Parse(const int argc, char **argv, bool useExePath)
2866	{
2867	bool result = true;
2868	// Read the names of the scene, environment and output files
2869	ReadCmdlineParams(argc, argv, "");
2870
2871	char *envFilename = new char[128];
2872
2873	char filename[64];
2874
2875	// Get the environment file name
2876	if (!GetParam(' ', 0, filename)) {
2877	// user didn't specified environment file explicitly, so
2878	strcpy(filename, "default.env");
2879	}
2880
2881
2882	if (useExePath) {
2883	char *path = GetPath(argv[0]);
2884	if (*path != 0)
2885	sprintf(envFilename, "%s/%s", path, filename);
2886	else
2887	strcpy(envFilename, filename);
2888
2889	delete path;
2890	}
2891	else
2892	strcpy(envFilename, filename);
2893
2894
2895	// Now it's time to read in environment file.
2896	if (!ReadEnvFile(envFilename)) {
2897	// error - bad input file name specified ?
2898	cerr<<"Error parsing environment file "<<envFilename<<endl;
2899	result = false;
2900	}
2901	delete envFilename;
2902
2903	// Parse the command line; options given on the command line subsume
2904	// stuff specified in the input environment file.
2905	ParseCmdline(argc, argv, 0);
2906
2907	SetStaticOptions();
2908
2909	// Check for request for help
2910	if (CheckForSwitch(argc, argv, '?')) {
2911	PrintUsage(cout);
2912	exit(0);
2913	}
2914
2915	return true;
2916	}
2917
2918	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: