Context Navigation

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

Revision 1500, 65.7 KB checked in by mattausch, 18 years ago (diff)
worked on gvs sampling

Rev	Line
[372]	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
[863]	22	using namespace std;
[372]	23
[863]	24	namespace GtpVisibilityPreprocessor {
[860]	25
[863]	26
[1004]	27	Environment *Environment::sEnvironment = NULL;
[372]	28
[1004]	29
	30	Environment *Environment::GetSingleton()
	31	{
	32	if (!sEnvironment)
	33	{
	34	sEnvironment = new Environment();
	35	}
	36
	37	return sEnvironment;
	38	}
	39
[1416]	40
[1004]	41	void Environment::DelSingleton()
	42	{
	43	DEL_PTR(sEnvironment);
	44	}
	45
	46
[372]	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)
[938]	68	DEL_PTR(optionalParams);
[372]	69	}
	70
	71	bool
	72	Environment::CheckForSwitch(const int argc,
[492]	73	char **argv,
	74	const char swtch) const
[372]	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,
[492]	154	char **argv,
	155	const char *optParams)
[372]	156	{
	157	int i;
	158
	159	// Make sure we are called for the first time
	160	if (optionalParams != NULL)
	161	return;
	162
[472]	163	numParams = (int)strlen(optParams) + 1;
[372]	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,
[1002]	264	const EOptType type,
	265	const char *abbrev,
	266	const char *defValue)
[372]	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;
[863]	291	options[numOptions].name = ::strdup(name);
[372]	292	// assign abbreviation, if requested
	293	if (abbrev != NULL) {
[863]	294	options[numOptions].abbrev = ::strdup(abbrev);
[372]	295	}
	296	// assign default value, if requested
	297	if (defValue != NULL) {
[863]	298	options[numOptions].defaultValue = ::strdup(defValue);
[372]	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
[938]	331	Environment::FindOption(const char *name, const bool isFatal) const
[372]	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
[472]	413	value = (Real)strtod(options[i].value, NULL);
[372]	414	} else {
	415	// option was not read, so use the default
[472]	416	value = (Real)strtod(options[i].defaultValue, NULL);
[372]	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;
[863]	631	options[i].value = ::strdup(value);
[372]	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,
[492]	642	char **argv,
	643	const int index)
[372]	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	char buff[256];
	801	envStream.getline(buff, 255);
	802	buff[8] = 0;
	803	if (strcmp(buff, "CGX_CF10") == 0)
	804	return;
	805
	806	ofstream cStream(filenameCoded);
	807	cStream<<"CGX_CF10";
	808
	809	// main loop
	810	for (;;) {
	811	// read in one line
	812	envStream.getline(buff, 255);
	813	if (!envStream)
	814	break;
	815	CodeString(buff, 255);
	816	cStream<<buff;
	817	}
	818
	819	}
	820
	821	bool
	822	Environment::ReadEnvFile(const char *envFilename)
[975]	823	{
[372]	824	char buff[MaxStringLength], name[MaxStringLength];
	825	char s, t;
	826	int i, line = 0;
	827	bool found;
	828	igzstream envStream(envFilename);
	829
	830	// some error had occured
	831	if (envStream.fail()) {
	832	cerr << "Error: Can't open file " << envFilename << " for reading (err. "
	833	<< envStream.rdstate() << ").\n";
	834	return false;
	835	}
[971]	836
[372]	837	name[0] = '\0';
	838
	839	// bool coded;
	840	// envStream.getline(buff, 255);
	841	// buff[8] = 0;
	842	// if (strcmp(buff, "CGX_CF10") == 0)
	843	// coded = true;
	844	// else {
	845	// coded = false;
	846	// envStream.Rewind();
	847	// }
	848
	849	// main loop
	850	for (;;) {
	851	// read in one line
	852	envStream.getline(buff, 255);
	853
	854	if (!envStream)
	855	break;
	856
	857	// if (coded)
	858	// DecodeString(buff, 255);
	859
	860	line++;
	861	// get rid of comments
	862	s = strchr(buff, '#');
	863	if (s != NULL)
	864	*s = '\0';
	865
	866	// get one identifier
	867	s = ParseString(buff, name);
	868	// parse line
	869	while (s != NULL) {
	870	// it's a group name - make the full name
	871	if (*s == '{') {
	872	strcat(name, ".");
	873	s++;
	874	s = ParseString(s, name);
	875	continue;
	876	}
	877	// end of group
	878	if (*s == '}') {
	879	if (strlen(name) == 0) {
	880	cerr << "Error: unpaired } in " << envFilename << " (line "
	881	<< line << ").\n";
	882	envStream.close();
	883	return false;
	884	}
	885	name[strlen(name) - 1] = '\0';
	886	t = strrchr(name, '.');
	887	if (t == NULL)
	888	name[0] = '\0';
	889	else
	890	*(t + 1) = '\0';
	891	s++;
	892	s = ParseString(s, name);
	893	continue;
	894	}
	895	// find variable name in the table
	896	found = false;
	897	for (i = 0; i < numOptions; i++)
	898	if (!strcmp(name, options[i].name)) {
	899	found = true;
	900	break;
	901	}
	902	if (!found) {
	903	cerr << "Warning: unknown option " << name << " in environment file "
	904	<< envFilename << " (line " << line << ").\n";
	905	} else
	906	switch (options[i].type) {
	907	case optInt: {
	908	strtol(s, &t, 10);
	909	if (t == s \|\| (t != ' ' && t != '\t' &&
	910	t != '\0' && t != '}')) {
	911	cerr << "Error: Mismatch in int variable " << name << " in "
	912	<< "environment file " << envFilename << " (line "
	913	<< line << ").\n";
	914	envStream.close();
	915	return false;
	916	}
	917	if (options[i].value != NULL)
	918	delete options[i].value;
	919	options[i].value = new char[t - s + 1];
	920	strncpy(options[i].value, s, t - s);
	921	options[i].value[t - s] = '\0';
	922	s = t;
	923	break;
	924	}
	925	case optFloat: {
	926	strtod(s, &t);
	927	if (t == s \|\| (t != ' ' && t != '\t' &&
	928	t != '\0' && t != '}')) {
	929	cerr << "Error: Mismatch in Real variable " << name << " in "
	930	<< "environment file " << envFilename << " (line "
	931	<< line << ").\n";
	932	envStream.close();
	933	return false;
	934	}
	935	if (options[i].value != NULL)
	936	delete options[i].value;
	937	options[i].value = new char[t - s + 1];
	938	strncpy(options[i].value, s, t - s);
	939	options[i].value[t - s] = '\0';
	940	s = t;
	941	break;
	942	}
	943	case optBool: {
	944	t = s;
	945	while ((t >= 'a' && t <= 'z') \|\|
	946	(t >= 'A' && t <= 'Z') \|\|
	947	t == '+' \|\| t == '-')
	948	t++;
	949	if (((!strncasecmp(s, "true", t - s) && t - s == 4) \|\|
	950	(!strncasecmp(s, "false", t - s) && t - s == 5) \|\|
	951	(!strncasecmp(s, "YES", t -s) && t - s == 3) \|\|
	952	(!strncasecmp(s, "NO", t - s) && t - s == 2) \|\|
	953	(!strncasecmp(s, "ON", t - s) && t - s == 2) \|\|
	954	(!strncasecmp(s, "OFF", t - s) && t - s == 3) \|\|
	955	(t - s == 1 && (s == '+' \|\| s == '-'))) &&
	956	(t == ' ' \|\| t == '\t' \|\| t == '\0' \|\| t == '}')) {
	957	if (options[i].value != NULL)
	958	delete options[i].value;
	959	options[i].value = new char[t - s + 1];
	960	strncpy(options[i].value, s, t - s);
	961	options[i].value[t - s] = '\0';
	962	s = t;
	963	}
	964	else {
	965	cerr << "Error: Mismatch in bool variable " << name << " in "
	966	<< "environment file " << envFilename << " (line "
	967	<< line << ").\n";
	968	envStream.close();
	969	return false;
	970	}
	971	break;
	972	}
	973	case optVector:{
	974	strtod(s, &t);
	975	if (t == ' ' \|\| t == '\t') {
	976	while (t == ' ' \|\| t == '\t')
	977	t++;
	978	if (*t != ',')
	979	t--;
	980	}
	981	if (t == s \|\| (t != ' ' && t != '\t' && *t != ',')) {
	982	cerr << "Error: Mismatch in vector variable " << name << " in "
	983	<< "environment file " << envFilename << " (line "
	984	<< line << ").\n";
	985	envStream.close();
	986	return false;
	987	}
	988	char *u;
	989	strtod(t, &u);
	990	t = u;
	991	if (t == ' ' \|\| t == '\t') {
	992	while (t == ' ' \|\| t == '\t')
	993	t++;
	994	if (*t != ',')
	995	t--;
	996	}
	997	if (t == s \|\| (t != ' ' && t != '\t' && *t != ',')) {
	998	cerr << "Error: Mismatch in vector variable " << name << " in "
	999	<< "environment file " << envFilename << " (line "
	1000	<< line << ").\n";
	1001	envStream.close();
	1002	return false;
	1003	}
	1004	strtod(t, &u);
	1005	t = u;
	1006	if (t == s \|\| (t != ' ' && t != '\t' &&
	1007	t != '\0' && t != '}')) {
	1008	cerr << "Error: Mismatch in vector variable " << name << " in "
	1009	<< "environment file " << envFilename << " (line "
	1010	<< line << ").\n";
	1011	envStream.close();
	1012	return false;
	1013	}
	1014	if (options[i].value != NULL)
	1015	delete options[i].value;
	1016	options[i].value = new char[t - s + 1];
	1017	strncpy(options[i].value, s, t - s);
	1018	options[i].value[t - s] = '\0';
	1019	s = t;
	1020	break;
	1021	}
	1022	case optString: {
	1023	if (options[i].value != NULL)
	1024	delete options[i].value;
	1025	options[i].value = new char[strlen(s) + 1];
	1026	strcpy(options[i].value, s);
	1027	s += strlen(s);
	1028	break;
	1029	}
	1030	default: {
	1031	Debug << "Internal error: Unknown type of option.\n" << flush;
	1032	exit(1);
	1033	}
	1034	}
	1035	// prepare the variable name for next pass
	1036	t = strrchr(name, '.');
	1037	if (t == NULL)
	1038	name[0] = '\0';
	1039	else
	1040	*(t + 1) = '\0';
	1041	// get next identifier
	1042	s = ParseString(s, name);
	1043	}
	1044	}
	1045	envStream.close();
	1046	return true;
	1047	}
	1048
	1049	void
	1050	Environment::PrintUsage(ostream &s) const
	1051	{
	1052	// Print out all environment variable names
	1053	s << "Registered options:\n";
	1054	for (int j = 0; j < numOptions; j++)
	1055	s << options[j] << "\n";
	1056	s << flush;
	1057	}
	1058
[859]	1059	/**
	1060	Input scene filename. Currently simplified X3D (.x3d), Unigraphics (.dat),
	1061	and UNC (.ply) formats are supported.
	1062	*/
[372]	1063
	1064	Environment::Environment()
	1065	{
	1066	optionalParams = NULL;
	1067	paramRows = 0;
	1068	numParams = 0;
	1069	params = NULL;
[539]	1070	maxOptions = 500;
[372]	1071
	1072
	1073	// this is maximal nuber of options.
	1074	numOptions = 0;
	1075
	1076	options = new COption[maxOptions];
	1077
	1078	if (options == NULL ) {
	1079	Debug << "Error: Memory allocation failed.\n";
	1080	exit(1);
	1081	}
	1082
	1083	// register all basic options
	1084
	1085	RegisterOption("Limits.threshold", optFloat, NULL, "0.01");
	1086	RegisterOption("Limits.small", optFloat, NULL, "1e-6");
	1087	RegisterOption("Limits.infinity", optFloat, NULL, "1e6");
	1088
	1089	RegisterOption("Scene.filename",
[492]	1090	optString,
	1091	"scene_filename=",
	1092	"atlanta2.x3d");
[372]	1093
	1094	RegisterOption("Unigraphics.meshGrouping",
[492]	1095	optInt,
	1096	"unigraphics_mesh_grouping=",
	1097	"0");
[372]	1098
[1221]	1099	RegisterOption("ObjParser.meshGrouping",
	1100	optInt,
	1101	"objparser_mesh_grouping=",
	1102	"0");
[372]	1103
	1104	RegisterOption("KdTree.Termination.minCost",
[492]	1105	optInt,
	1106	"kd_term_min_cost=",
	1107	"10");
[859]	1108
[752]	1109	RegisterOption("KdTree.Termination.maxNodes",
	1110	optInt,
	1111	"kd_term_max_nodes=",
	1112	"200000");
[859]	1113
[372]	1114	RegisterOption("KdTree.Termination.maxDepth",
[492]	1115	optInt,
	1116	"kd_term_max_depth=",
	1117	"20");
[372]	1118
	1119	RegisterOption("KdTree.Termination.maxCostRatio",
[492]	1120	optFloat,
	1121	"kd_term_max_cost_ratio=",
	1122	"1.5");
[372]	1123
	1124	RegisterOption("KdTree.Termination.ct_div_ci",
[492]	1125	optFloat,
	1126	"kd_term_ct_div_ci=",
	1127	"1.0");
[372]	1128
	1129	RegisterOption("KdTree.splitMethod",
[492]	1130	optString,
	1131	"kd_split_method=",
	1132	"spatialMedian");
[372]	1133
	1134	RegisterOption("KdTree.splitBorder",
	1135	optFloat,
[492]	1136	"kd_split_border=",
[372]	1137	"0.1");
	1138
	1139	RegisterOption("KdTree.sahUseFaces",
	1140	optBool,
[492]	1141	"kd_sah_use_faces=",
[372]	1142	"true");
	1143
	1144	RegisterOption("MeshKdTree.Termination.minCost",
	1145	optInt,
[492]	1146	"kd_term_min_cost=",
[372]	1147	"10");
	1148
	1149	RegisterOption("MeshKdTree.Termination.maxDepth",
	1150	optInt,
[492]	1151	"kd_term_max_depth=",
[372]	1152	"20");
	1153
	1154	RegisterOption("MeshKdTree.Termination.maxCostRatio",
	1155	optFloat,
[492]	1156	"kd_term_max_cost_ratio=",
[372]	1157	"1.5");
	1158
	1159	RegisterOption("MeshKdTree.Termination.ct_div_ci",
	1160	optFloat,
[492]	1161	"kd_term_ct_div_ci=",
[372]	1162	"1.0");
	1163
	1164	RegisterOption("MeshKdTree.splitMethod",
	1165	optString,
[492]	1166	"kd_split_method=",
[372]	1167	"spatialMedian");
	1168
	1169	RegisterOption("MeshKdTree.splitBorder",
	1170	optFloat,
[492]	1171	"kd_split_border=",
[372]	1172	"0.1");
	1173
[508]	1174	RegisterOption("SamplingPreprocessor.totalSamples",
[372]	1175	optInt,
[492]	1176	"total_samples=",
[372]	1177	"1000000");
	1178
[508]	1179	RegisterOption("SamplingPreprocessor.samplesPerPass",
[372]	1180	optInt,
[492]	1181	"samples_per_pass=",
[372]	1182	"10");
	1183
[811]	1184	RegisterOption("RenderSampler.samples",
	1185	optInt,
	1186	"render_sampler_samples=",
	1187	"1000");
	1188
[1001]	1189	RegisterOption("RenderSampler.visibleThreshold",
	1190	optInt,
	1191	"render_sampler_visible_threshold=",
	1192	"0");
	1193
	1194
[997]	1195	RegisterOption("RenderSampler.useOcclusionQueries",
	1196	optBool,
	1197	"render_sampler_use_occlusion_queries=",
	1198	"true");
	1199
	1200	RegisterOption("VssPreprocessor.initialSamples",
[492]	1201	optInt,
[1486]	1202	"vss_initial_samples=",
[492]	1203	"100000");
	1204
[1001]	1205	RegisterOption("VssPreprocessor.testBeamSampling",
	1206	optBool,
[1486]	1207	"vss_beam_sampling=",
[1001]	1208	"false");
[532]	1209
[469]	1210	RegisterOption("VssPreprocessor.vssSamples",
[492]	1211	optInt,
	1212	"vss_samples=",
	1213	"1000000");
[376]	1214
[427]	1215	RegisterOption("VssPreprocessor.vssSamplesPerPass",
[492]	1216	optInt,
	1217	"vss_samples_per_pass=",
	1218	"1000");
	1219
[469]	1220	RegisterOption("VssPreprocessor.samplesPerPass",
[492]	1221	optInt,
[1486]	1222	"vss_samples_per_pass=",
[492]	1223	"100000");
[376]	1224
[403]	1225	RegisterOption("VssPreprocessor.useImportanceSampling",
[492]	1226	optBool,
	1227	"vss_use_importance=",
	1228	"true");
[403]	1229
[674]	1230	RegisterOption("VssPreprocessor.enlargeViewSpace",
	1231	optBool,
	1232	"vss_enlarge_viewspace=",
[675]	1233	"false");
[674]	1234
[490]	1235	RegisterOption("VssPreprocessor.loadInitialSamples",
	1236	optBool,
[674]	1237	"vss_load_loadInitialSamples=",
[490]	1238	"false");
[445]	1239
[490]	1240	RegisterOption("VssPreprocessor.storeInitialSamples",
	1241	optBool,
[674]	1242	"vss_store_storedInitialSamples=",
[490]	1243	"false");
	1244
[1486]	1245	RegisterOption("VssPreprocessor.useViewSpaceBox",
[501]	1246	optBool,
[674]	1247	"vss_use_viewspace_box=",
[1486]	1248	"false");
[501]	1249
	1250
[445]	1251
[1486]	1252	/************************************************************************************/
	1253	/* GvsPrerpocessor related options */
	1254	/************************************************************************************/
[445]	1255
[1486]	1256
	1257	RegisterOption("GvsPreprocessor.totalSamples",
	1258	optInt,
	1259	"gvs_total_samples=",
	1260	"1000000");
	1261
	1262	RegisterOption("GvsPreprocessor.samplesPerPass",
	1263	optInt,
	1264	"gvs_samples_per_pass=",
	1265	"100000");
	1266
	1267	RegisterOption("GvsPreprocessor.initialSamples",
	1268	optInt,
	1269	"gvs_initial_samples=",
	1270	"256");
	1271
	1272	RegisterOption("GvsPreprocessor.epsilon",
	1273	optFloat,
	1274	"gvs_epsilon",
	1275	"0.00001");
	1276
[1500]	1277	RegisterOption("GvsPreprocessor.threshold",
	1278	optFloat,
	1279	"gvs_threshold",
	1280	"1.5");
[1486]	1281
[1500]	1282
[1486]	1283	/***********************************************************************************/
	1284	/* View cells related options */
	1285	/***********************************************************************************/
	1286
	1287
[508]	1288	RegisterOption("ViewCells.type",
	1289	optString,
[664]	1290	"view_cells_type=",
[662]	1291	"vspBspTree");
[372]	1292
[662]	1293	RegisterOption("ViewCells.samplingType",
	1294	optString,
[664]	1295	"view_cells_sampling_type=",
[662]	1296	"box");
	1297
[666]	1298	RegisterOption("ViewCells.mergeStats",
[660]	1299	optString,
[666]	1300	"view_cells_merge_stats=",
	1301	"mergeStats.log");
[660]	1302
[664]	1303	RegisterOption("ViewCells.Evaluation.statsPrefix",
[660]	1304	optString,
[664]	1305	"view_cells_evaluation_stats_prefix=",
[660]	1306	"viewCells");
[1418]	1307
[735]	1308	RegisterOption("ViewCells.Evaluation.histogram",
	1309	optBool,
	1310	"view_cells_evaluation_histogram=",
	1311	"false");
	1312
[997]	1313	RegisterOption("ViewCells.Evaluation.histoStepSize",
[735]	1314	optInt,
[997]	1315	"view_cells_evaluation_histo_step_size=",
[744]	1316	"5000");
[735]	1317
[728]	1318	RegisterOption("ViewCells.renderCostEvaluationType",
	1319	optString,
	1320	"view_cells_render_cost_evaluation=",
	1321	"perobject");
	1322
[660]	1323	RegisterOption("ViewCells.active",
	1324	optInt,
[664]	1325	"view_cells_active=",
[660]	1326	"1000");
[581]	1327
[574]	1328	RegisterOption("ViewCells.Construction.samples",
	1329	optInt,
	1330	"view_cells_construction_samples=",
[1134]	1331	"0");
[574]	1332
	1333	RegisterOption("ViewCells.Construction.samplesPerPass",
	1334	optInt,
	1335	"view_cells_construction_samples_per_pass=",
	1336	"500000");
	1337
[508]	1338	RegisterOption("ViewCells.PostProcess.samples",
	1339	optInt,
[712]	1340	"view_cells_post_process_samples=",
[1134]	1341	"0");
[421]	1342
[508]	1343	RegisterOption("ViewCells.Visualization.samples",
	1344	optInt,
	1345	"view_cells_visualization_samples=",
[1134]	1346	"0");
[372]	1347
[1020]	1348	RegisterOption("ViewCells.Visualization.maxOutput",
	1349	optInt,
	1350	"view_cells_visualization_max_output=",
	1351	"20");
	1352
[697]	1353	RegisterOption("ViewCells.Filter.maxSize",
	1354	optInt,
	1355	"view_cells_filter_max_size=",
	1356	"4");
	1357
	1358	RegisterOption("ViewCells.Filter.width",
	1359	optFloat,
	1360	"view_cells_filter_width=",
[746]	1361	"200.0");
[697]	1362
[508]	1363	RegisterOption("ViewCells.loadFromFile",
	1364	optBool,
[664]	1365	"view_cells_load_from_file=",
[508]	1366	"false");
[485]	1367
[586]	1368	RegisterOption("ViewCells.PostProcess.refine",
	1369	optBool,
[664]	1370	"view_cells_refine=",
[586]	1371	"false");
	1372
	1373	RegisterOption("ViewCells.PostProcess.compress",
	1374	optBool,
[664]	1375	"view_cells_post_process_compress=",
[586]	1376	"false");
	1377
[662]	1378	RegisterOption("ViewCells.Evaluation.samples",
	1379	optInt,
	1380	"view_cells_evaluation_samples=",
	1381	"8000000");
	1382
[722]	1383	RegisterOption("ViewCells.Evaluation.samplingType",
[837]	1384	optString,
	1385	"view_cells_evaluation_sampling_type=",
	1386	"box");
[722]	1387
[662]	1388	RegisterOption("ViewCells.Evaluation.samplesPerPass",
	1389	optInt,
	1390	"view_cells_evaluation_samples_per_pass=",
	1391	"300000");
	1392
[508]	1393	RegisterOption("ViewCells.exportToFile",
	1394	optBool,
[676]	1395	"view_cells_export_to_file=",
[508]	1396	"false");
	1397
[844]	1398	RegisterOption("ViewCells.exportPvs",
	1399	optBool,
	1400	"view_cells_export_pvs=",
	1401	"false");
	1402
[840]	1403	RegisterOption("ViewCells.exportBboxesForPvs",
	1404	optBool,
[844]	1405	"view_cells_export_bounding_boxes=",
[840]	1406	"true");
	1407
	1408	RegisterOption("ViewCells.boxesFilename",
	1409	optString,
	1410	"view_cells_boxes_filename=",
	1411	"boxes.out");
	1412
[664]	1413	RegisterOption("ViewCells.evaluateViewCells",
	1414	optBool,
[670]	1415	"view_cells_evaluate=",
[664]	1416	"false");
	1417
[508]	1418	RegisterOption("ViewCells.maxViewCells",
[667]	1419	optInt,
	1420	"view_cells_max_view_cells=",
	1421	"0");
[508]	1422
[511]	1423	RegisterOption("ViewCells.maxPvsRatio",
	1424	optFloat,
	1425	"view_cells_max_pvs_ratio=",
	1426	"0.1");
[508]	1427
	1428	RegisterOption("ViewCells.filename",
[667]	1429	optString,
	1430	"view_cells_filename=",
	1431	"atlanta_viewcells_large.x3d");
[508]	1432
	1433	RegisterOption("ViewCells.height",
[667]	1434	optFloat,
	1435	"view_cells_height=",
	1436	"5.0");
[508]	1437
	1438	RegisterOption("ViewCells.Visualization.colorCode",
[667]	1439	optString,
[708]	1440	"view_cells_visualization_color_code=",
[667]	1441	"PVS");
[482]	1442
[667]	1443	RegisterOption("ViewCells.Visualization.clipPlanePos",
	1444	optFloat,
[708]	1445	"view_cells_visualization_clip_plane_pos=",
[667]	1446	"0.35");
[579]	1447
[508]	1448	RegisterOption("ViewCells.Visualization.exportGeometry",
[667]	1449	optBool,
[708]	1450	"view_cells_visualization_export_geometry=",
[667]	1451	"false");
[445]	1452
[667]	1453	RegisterOption("ViewCells.Visualization.exportRays",
	1454	optBool,
[708]	1455	"view_cells_visualization_export_rays=",
[667]	1456	"false");
	1457
[564]	1458	RegisterOption("ViewCells.processOnlyValidViewCells",
[667]	1459	optBool,
[708]	1460	"view_cells_process_only_valid_view_cells=",
[667]	1461	"false");
[660]	1462
[580]	1463	RegisterOption("ViewCells.PostProcess.maxCostRatio",
	1464	optFloat,
[667]	1465	"view_cells_post_process_max_cost_ratio=",
[580]	1466	"0.9");
	1467
	1468	RegisterOption("ViewCells.PostProcess.renderCostWeight",
	1469	optFloat,
[667]	1470	"view_cells_post_process_render_cost_weight",
[580]	1471	"0.5");
	1472
	1473	RegisterOption("ViewCells.PostProcess.avgCostMaxDeviation",
	1474	optFloat,
[1143]	1475	"view_cells_avgcost_max_deviations",
[580]	1476	"0.5");
	1477
	1478	RegisterOption("ViewCells.PostProcess.maxMergesPerPass",
	1479	optInt,
[667]	1480	"view_cells_post_process_max_merges_per_pass=",
[580]	1481	"500");
	1482
	1483	RegisterOption("ViewCells.PostProcess.minViewCells",
	1484	optInt,
[667]	1485	"view_cells_post_process_min_view_cells=",
[580]	1486	"1000");
	1487
	1488	RegisterOption("ViewCells.PostProcess.useRaysForMerge",
	1489	optBool,
	1490	"view_cells_post_process_use_rays_for_merge=",
	1491	"false");
[591]	1492
	1493	RegisterOption("ViewCells.PostProcess.merge",
	1494	optBool,
[666]	1495	"view_cells_post_process_merge=",
[591]	1496	"true");
[580]	1497
	1498	RegisterOption("ViewCells.Visualization.exportMergedViewCells",
	1499	optBool,
	1500	"view_cells_viz_export_merged_viewcells=",
	1501	"false");
	1502
[582]	1503	RegisterOption("ViewCells.maxStaticMemory",
	1504	optFloat,
	1505	"view_cells_max_static_mem=",
	1506	"8.0");
[580]	1507
[660]	1508	RegisterOption("ViewCells.Visualization.useClipPlane",
[591]	1509	optBool,
[660]	1510	"view_cells_viz_use_clip_plane=",
[591]	1511	"false");
	1512
[666]	1513	RegisterOption("ViewCells.showVisualization",
	1514	optBool,
	1515	"view_cells_show_visualization=",
	1516	"false");
	1517
[660]	1518	RegisterOption("ViewCells.Visualization.clipPlaneAxis",
[591]	1519	optInt,
[660]	1520	"view_cells_viz_clip_plane_axis=",
[591]	1521	"0");
	1522
[1159]	1523
[1418]	1524	/****************************************************************************/
	1525	/* Render simulation related options */
	1526	/****************************************************************************/
[372]	1527
[406]	1528
[508]	1529	RegisterOption("Simulation.objRenderCost",
	1530	optFloat,
	1531	"simulation_obj_render_cost",
	1532	"1.0");
[409]	1533
[508]	1534	RegisterOption("Simulation.vcOverhead",
	1535	optFloat,
	1536	"simulation_vc_overhead",
	1537	"0.05");
[445]	1538
[508]	1539	RegisterOption("Simulation.moveSpeed",
	1540	optFloat,
	1541	"simulation_moveSpeed",
	1542	"1.0");
[445]	1543
	1544
	1545
[1486]	1546	/******************************************************************/
	1547	/* Bsp tree related options */
	1548	/******************************************************************/
[445]	1549
[372]	1550
[508]	1551	RegisterOption("BspTree.Construction.input",
	1552	optString,
	1553	"bsp_construction_input=",
	1554	"fromViewCells");
[372]	1555
[660]	1556	RegisterOption("BspTree.subdivisionStats",
	1557	optString,
[666]	1558	"bsp_subdivision_stats=",
[660]	1559	"bspSubdivisionStats.log");
	1560
[508]	1561	RegisterOption("BspTree.Construction.samples",
	1562	optInt,
	1563	"bsp_construction_samples=",
	1564	"100000");
[390]	1565
[508]	1566	RegisterOption("BspTree.Construction.epsilon",
	1567	optFloat,
[1023]	1568	"bsp_construction_epsilon=",
[508]	1569	"0.002");
[397]	1570
[508]	1571	RegisterOption("BspTree.Termination.minPolygons",
	1572	optInt,
	1573	"bsp_term_min_polygons=",
	1574	"5");
[409]	1575
[508]	1576	RegisterOption("BspTree.Termination.minPvs",
	1577	optInt,
	1578	"bsp_term_min_pvs=",
	1579	"20");
[372]	1580
[587]	1581	RegisterOption("BspTree.Termination.minProbability",
[508]	1582	optFloat,
[587]	1583	"bsp_term_min_probability=",
[508]	1584	"0.001");
[424]	1585
[508]	1586	RegisterOption("BspTree.Termination.maxRayContribution",
	1587	optFloat,
	1588	"bsp_term_ray_contribution=",
	1589	"0.005");
[372]	1590
[508]	1591	RegisterOption("BspTree.Termination.minAccRayLenght",
	1592	optFloat,
	1593	"bsp_term_min_acc_ray_length=",
	1594	"50");
[372]	1595
[508]	1596	RegisterOption("BspTree.Termination.minRays",
	1597	optInt,
	1598	"bsp_term_min_rays=",
	1599	"-1");
[372]	1600
[508]	1601	RegisterOption("BspTree.Termination.ct_div_ci",
	1602	optFloat,
	1603	"bsp_term_ct_div_ci=",
	1604	"0.0");
[372]	1605
[508]	1606	RegisterOption("BspTree.Termination.maxDepth",
	1607	optInt,
	1608	"bsp_term_max_depth=",
	1609	"100");
[372]	1610
[508]	1611	RegisterOption("BspTree.Termination.maxCostRatio",
	1612	optFloat,
	1613	"bsp_term_axis_aligned_max_cost_ratio=",
	1614	"1.5");
[372]	1615
[508]	1616	RegisterOption("BspTree.Termination.AxisAligned.ct_div_ci",
	1617	optFloat,
	1618	"bsp_term_axis_aligned_ct_div_ci=",
	1619	"0.5");
[372]	1620
[508]	1621	RegisterOption("BspTree.AxisAligned.splitBorder",
	1622	optFloat,
	1623	"bsp__axis_aligned_split_border=",
	1624	"0.1");
[372]	1625
[508]	1626	RegisterOption("BspTree.Termination.AxisAligned.minPolys",
	1627	optInt,
	1628	"bsp_term_axis_aligned_max_polygons=",
	1629	"50");
[379]	1630
[508]	1631	RegisterOption("BspTree.Termination.AxisAligned.minObjects",
	1632	optInt,
	1633	"bsp_term_min_objects=",
	1634	"3");
[441]	1635
[508]	1636	RegisterOption("BspTree.Termination.AxisAligned.minRays",
	1637	optInt,
	1638	"bsp_term_axis_aligned_min_rays=",
	1639	"-1");
[374]	1640
[508]	1641	RegisterOption("BspTree.splitPlaneStrategy",
	1642	optString,
	1643	"bsp_split_method=",
	1644	"leastSplits");
[424]	1645
[508]	1646	RegisterOption("BspTree.maxPolyCandidates",
	1647	optInt,
	1648	"bsp_max_poly_candidates=",
	1649	"20");
[469]	1650
[508]	1651	RegisterOption("BspTree.maxRayCandidates",
	1652	optInt,
	1653	"bsp_max_plane_candidates=",
	1654	"20");
[382]	1655
[508]	1656	RegisterOption("BspTree.maxTests",
	1657	optInt,
	1658	"bsp_max_tests=",
	1659	"5000");
[382]	1660
[587]	1661	RegisterOption("BspTree.Termination.maxViewCells",
	1662	optInt,
	1663	"bsp_max_view_cells=",
	1664	"5000");
	1665
[508]	1666	RegisterOption("BspTree.Visualization.exportSplits",
	1667	optBool,
	1668	"bsp_visualization.export_splits",
	1669	"false");
[445]	1670
[508]	1671	RegisterOption("BspTree.Factor.verticalSplits", optFloat, "bsp_factor_vertical=", "1.0");
	1672	RegisterOption("BspTree.Factor.largestPolyArea", optFloat, "bsp_factor_largest_poly=", "1.0");
	1673	RegisterOption("BspTree.Factor.blockedRays", optFloat, "bsp_factor_blocked=", "1.0");
	1674	RegisterOption("BspTree.Factor.leastSplits", optFloat, "bsp_factor_least_splits=", "1.0");
	1675	RegisterOption("BspTree.Factor.balancedPolys", optFloat, "bsp_factor_balanced_polys=", "1.0");
	1676	RegisterOption("BspTree.Factor.balancedViewCells", optFloat, "bsp_factor_balanced_view_cells=", "1.0");
	1677	RegisterOption("BspTree.Factor.leastRaySplits", optFloat, "bsp_factor_least_ray_splits=", "1.0");
	1678	RegisterOption("BspTree.Factor.balancedRays", optFloat, "bsp_factor_balanced_rays=", "1.0");
	1679	RegisterOption("BspTree.Factor.pvs", optFloat, "bsp_factor_pvs=", "1.0");
[408]	1680
[508]	1681	/************************************************************************************/
	1682	/* Preprocessor related options */
	1683	/************************************************************************************/
[408]	1684
[508]	1685	RegisterOption("Preprocessor.type",
	1686	optString,
	1687	"preprocessor=",
	1688	"sampling");
[408]	1689
[508]	1690	RegisterOption("Preprocessor.samplesFilename",
	1691	optString,
[676]	1692	"preprocessor_samples_filename=",
[508]	1693	"rays.out");
[408]	1694
[1379]	1695	RegisterOption("Preprocessor.loadMeshes",
[658]	1696	optBool,
[1486]	1697	"preprocessor_load_meshes=",
[1379]	1698	"true");
[658]	1699
[563]	1700	RegisterOption("Preprocessor.pvsRenderErrorSamples",
	1701	optInt,
[1444]	1702	"preprocessor_pvs_rendererror_samples=",
[563]	1703	"10000");
[682]	1704
	1705	RegisterOption("Preprocessor.useGlRenderer",
	1706	optBool,
	1707	"preprocessor_use_gl_renderer=",
	1708	"false");
	1709
[538]	1710	RegisterOption("Preprocessor.useGlDebugger",
	1711	optBool,
[682]	1712	"preprocessor_use_gl_debugger=",
[538]	1713	"false");
	1714
[534]	1715	RegisterOption("Preprocessor.detectEmptyViewSpace",
	1716	optBool,
[682]	1717	"preprocessor_detect_empty_viewspace=",
[534]	1718	"false");
	1719
[599]	1720	RegisterOption("Preprocessor.quitOnFinish",
	1721	optBool,
[1112]	1722	"preprocessor_quit_on_finish",
[599]	1723	"true");
[534]	1724
[685]	1725	RegisterOption("Preprocessor.computeVisibility",
	1726	optBool,
	1727	"preprocessor_compute_visibility=",
	1728	"true");
[682]	1729
[871]	1730	RegisterOption("Preprocessor.exportVisibility",
	1731	optBool,
[997]	1732	"preprocessor_export_visibility=",
[871]	1733	"true");
[682]	1734
[871]	1735	RegisterOption("Preprocessor.visibilityFile",
	1736	optString,
	1737	"preprocessor_visibility_file=",
	1738	"visibility.xml");
	1739
	1740	RegisterOption("Preprocessor.applyVisibilityFilter",
	1741	optBool,
[997]	1742	"preprocessor_apply_filter=",
[871]	1743	"true");
[904]	1744
	1745	RegisterOption("Preprocessor.applyVisibilitySpatialFilter",
	1746	optBool,
[997]	1747	"preprocessor_apply_spatial_filter=",
[904]	1748	"true");
[871]	1749
[878]	1750	RegisterOption("Preprocessor.visibilityFilterWidth",
	1751	optFloat,
	1752	"preprocessor_visibility_filter_width=",
	1753	"0.02");
[871]	1754
[991]	1755	RegisterOption("Preprocessor.histogram.maxValue",
	1756	optInt,
	1757	"preprocessor_histogram_max_value=",
	1758	"1000");
[871]	1759
[1221]	1760	RegisterOption("Preprocessor.rayCastMethod",
	1761	optInt,
	1762	"preprocessor_ray_cast_method=",
	1763	"0");
	1764
[991]	1765	RegisterOption("Preprocessor.histogram.intervals",
	1766	optInt,
	1767	"preprocessor_histogram_intervals=",
	1768	"20");
[878]	1769
[1414]	1770	RegisterOption("Preprocessor.exportKdTree",
	1771	optBool,
	1772	"preprocessor_export_kd_tree=",
	1773	"false");
[991]	1774
[1414]	1775	RegisterOption("Preprocessor.loadKdTree",
	1776	optBool,
	1777	"preprocessor_load_kd_tree=",
	1778	"false");
	1779
[1415]	1780	RegisterOption("Preprocessor.kdTreeFilename",
	1781	optString,
	1782	"preprocessor_kd_tree_filename=",
	1783	"vienna_kdtree.bin.gz");
	1784
[1414]	1785
[1415]	1786	/*************************************************************************/
	1787	/* VSS Preprocessor cells related options */
	1788	/*************************************************************************/
[1414]	1789
[469]	1790	RegisterOption("VssTree.maxDepth", optInt, "kd_depth=", "12");
	1791	RegisterOption("VssTree.minPvs", optInt, "kd_minpvs=", "1");
	1792	RegisterOption("VssTree.minRays", optInt, "kd_minrays=", "10");
	1793	RegisterOption("VssTree.maxCostRatio", optFloat, "maxcost=", "0.95");
	1794	RegisterOption("VssTree.maxRayContribution", optFloat, "maxraycontrib=", "0.5");
[382]	1795
[469]	1796	RegisterOption("VssTree.epsilon", optFloat, "kd_eps=", "1e-6");
	1797	RegisterOption("VssTree.ct_div_ci", optFloat, "kd_ctdivci=", "1.0");
	1798	RegisterOption("VssTree.randomize", optBool, "randomize", "false");
	1799	RegisterOption("VssTree.splitType", optString, "split=", "queries");
	1800	RegisterOption("VssTree.splitUseOnlyDrivingAxis", optBool, "splitdriving=", "false");
	1801	RegisterOption("VssTree.useRss", optBool, "rss=", "false");
	1802	RegisterOption("VssTree.numberOfEndPointDomains", optInt, "endpoints=", "10000");
[382]	1803
[469]	1804	RegisterOption("VssTree.minSize", optFloat, "minsize=", "0.001");
[382]	1805
[469]	1806	RegisterOption("VssTree.maxTotalMemory", optFloat, "mem=", "60.0");
	1807	RegisterOption("VssTree.maxStaticMemory", optFloat, "statmem=", "8.0");
[438]	1808
[469]	1809	RegisterOption("VssTree.queryType", optString, "qtype=", "static");
[438]	1810
[532]	1811
	1812
[469]	1813	RegisterOption("VssTree.queryPosWeight", optFloat, "qposweight=", "0.0");
[997]	1814	RegisterOption("VssTree.useRefDirSplits", optBool, "refdir=", "false");
[469]	1815	RegisterOption("VssTree.refDirAngle", optFloat, "refangle=", "10");
	1816	RegisterOption("VssTree.refDirBoxMaxSize", optFloat, "refboxsize=", "0.1");
	1817	RegisterOption("VssTree.accessTimeThreshold", optInt, "accesstime=", "1000");
	1818	RegisterOption("VssTree.minCollapseDepth", optInt, "colldepth=", "4");
[446]	1819
[469]	1820	RegisterOption("VssTree.interleaveDirSplits", optBool, "interleavedirsplits", "true");
	1821	RegisterOption("VssTree.dirSplitDepth", optInt, "dirsplidepth=", "10");
	1822
	1823
	1824	RegisterOption("RssPreprocessor.initialSamples",
	1825	optInt,
[1486]	1826	"rss_initial_samples=",
[469]	1827	"100000");
	1828
[463]	1829	RegisterOption("RssPreprocessor.vssSamples",
[508]	1830	optInt,
	1831	"rss_vss_samples=",
	1832	"1000000");
	1833
[469]	1834	RegisterOption("RssPreprocessor.vssSamplesPerPass",
[508]	1835	optInt,
	1836	"rss_vss_samples_per_pass=",
	1837	"1000");
	1838
[492]	1839	RegisterOption("RssPreprocessor.samplesPerPass",
[508]	1840	optInt,
	1841	"rss_samples_per_pass=",
	1842	"100000");
	1843
[469]	1844	RegisterOption("RssPreprocessor.useImportanceSampling",
[508]	1845	optBool,
[1112]	1846	"rss_use_importance",
[508]	1847	"true");
	1848
[492]	1849	RegisterOption("RssPreprocessor.objectBasedSampling",
[508]	1850	optBool,
[1112]	1851	"rss_object_based_sampling",
[508]	1852	"true");
	1853
[492]	1854	RegisterOption("RssPreprocessor.directionalSampling",
[508]	1855	optBool,
[1112]	1856	"rss_directional_sampling",
[508]	1857	"false");
	1858
[1199]	1859	RegisterOption("RssTree.hybridDepth", optInt, "hybrid_depth=", "10");
[469]	1860	RegisterOption("RssTree.maxDepth", optInt, "kd_depth=", "12");
	1861	RegisterOption("RssTree.minPvs", optInt, "kd_minpvs=", "1");
	1862	RegisterOption("RssTree.minRays", optInt, "kd_minrays=", "10");
	1863	RegisterOption("RssTree.maxCostRatio", optFloat, "maxcost=", "0.95");
	1864	RegisterOption("RssTree.maxRayContribution", optFloat, "maxraycontrib=", "0.5");
[508]	1865
[469]	1866	RegisterOption("RssTree.epsilon", optFloat, "kd_eps=", "1e-6");
	1867	RegisterOption("RssTree.ct_div_ci", optFloat, "kd_ctdivci=", "1.0");
[997]	1868	RegisterOption("RssTree.randomize", optBool, "randomize=", "false");
[1199]	1869	RegisterOption("RssTree.splitType", optString, "rss_split=", "queries");
[469]	1870	RegisterOption("RssTree.splitUseOnlyDrivingAxis", optBool, "splitdriving=", "false");
[508]	1871
[469]	1872	RegisterOption("RssTree.numberOfEndPointDomains", optInt, "endpoints=", "10000");
[508]	1873
[469]	1874	RegisterOption("RssTree.minSize", optFloat, "minsize=", "0.001");
[508]	1875
[469]	1876	RegisterOption("RssTree.maxTotalMemory", optFloat, "mem=", "60.0");
	1877	RegisterOption("RssTree.maxStaticMemory", optFloat, "statmem=", "8.0");
[508]	1878
[469]	1879	RegisterOption("RssTree.queryType", optString, "qtype=", "static");
[508]	1880
[469]	1881	RegisterOption("RssTree.queryPosWeight", optFloat, "qposweight=", "0.0");
	1882	RegisterOption("RssTree.useRefDirSplits", optBool, "refdir", "false");
	1883	RegisterOption("RssTree.refDirAngle", optFloat, "refangle=", "10");
	1884	RegisterOption("RssTree.refDirBoxMaxSize", optFloat, "refboxsize=", "0.1");
	1885	RegisterOption("RssTree.accessTimeThreshold", optInt, "accesstime=", "1000");
	1886	RegisterOption("RssTree.minCollapseDepth", optInt, "colldepth=", "4");
[508]	1887
[997]	1888	RegisterOption("RssTree.interleaveDirSplits", optBool, "interleavedirsplits=", "true");
[469]	1889	RegisterOption("RssTree.dirSplitDepth", optInt, "dirsplidepth=", "10");
[997]	1890	RegisterOption("RssTree.importanceBasedCost", optBool, "importance_based_cost=", "true");
[492]	1891	RegisterOption("RssTree.maxRays", optInt, "rss_max_rays=", "2000000");
[508]	1892
[516]	1893	RegisterOption("RssTree.perObjectTree", optBool, "rss_per_object_tree", "false");
	1894
[997]	1895	RegisterOption("RssPreprocessor.Export.pvs", optBool, "rss_export_pvs=", "false");
	1896	RegisterOption("RssPreprocessor.Export.rssTree", optBool, "rss_export_rss_tree=", "false");
	1897	RegisterOption("RssPreprocessor.Export.rays", optBool, "rss_export_rays=", "false");
[469]	1898	RegisterOption("RssPreprocessor.Export.numRays", optInt, "rss_export_num_rays=", "5000");
[997]	1899	RegisterOption("RssPreprocessor.useViewcells", optBool, "rss_use_viewcells=", "false");
[563]	1900	RegisterOption("RssPreprocessor.updateSubdivision",
	1901	optBool,
[997]	1902	"rss_update_subdivision=",
[563]	1903	"false");
[463]	1904
[492]	1905
[508]	1906	/************************************************************************************/
[1023]	1907	/* Rss preprocessor related options */
[508]	1908	/************************************************************************************/
	1909
	1910
[490]	1911	RegisterOption("RssPreprocessor.loadInitialSamples",
[508]	1912	optBool,
	1913	"vss_load_loadInitialSamples=",
	1914	"false");
[445]	1915
[490]	1916	RegisterOption("RssPreprocessor.storeInitialSamples",
[508]	1917	optBool,
	1918	"vss_store_storeInitialSamples=",
	1919	"false");
[490]	1920
[508]	1921
	1922	/************************************************************************************/
[1023]	1923	/* View space partition BSP tree related options */
[508]	1924	/************************************************************************************/
	1925
[654]	1926	RegisterOption("VspBspTree.Termination.minGlobalCostRatio",
	1927	optFloat,
[997]	1928	"vsp_bsp_term_min_global_cost_ratio=",
[654]	1929	"0.0001");
[508]	1930
[655]	1931	RegisterOption("VspBspTree.useSplitCostQueue",
	1932	optBool,
[667]	1933	"vsp_bsp_use_split_cost_queue=",
[655]	1934	"true");
	1935
[654]	1936	RegisterOption("VspBspTree.Termination.globalCostMissTolerance",
	1937	optInt,
[997]	1938	"vsp_bsp_term_global_cost_miss_tolerance=",
[654]	1939	"4");
	1940
[469]	1941	RegisterOption("VspBspTree.Termination.minPolygons",
[508]	1942	optInt,
	1943	"vsp_bsp_term_min_polygons=",
[1134]	1944	"-1");
[445]	1945
[469]	1946	RegisterOption("VspBspTree.Termination.minPvs",
[508]	1947	optInt,
	1948	"vsp_bsp_term_min_pvs=",
	1949	"20");
[660]	1950
[547]	1951	RegisterOption("VspBspTree.Termination.minProbability",
[508]	1952	optFloat,
[547]	1953	"vsp_bsp_term_min_probability=",
[508]	1954	"0.001");
[445]	1955
[660]	1956	RegisterOption("VspBspTree.subdivisionStats",
	1957	optString,
	1958	"vsp_bsp_subdivision_stats=",
	1959	"vspBspSubdivisionStats.log");
	1960
[469]	1961	RegisterOption("VspBspTree.Termination.maxRayContribution",
[508]	1962	optFloat,
	1963	"vsp_bsp_term_ray_contribution=",
[1134]	1964	"2");
[463]	1965
[469]	1966	RegisterOption("VspBspTree.Termination.minAccRayLenght",
[508]	1967	optFloat,
	1968	"vsp_bsp_term_min_acc_ray_length=",
	1969	"50");
[445]	1970
[469]	1971	RegisterOption("VspBspTree.Termination.minRays",
[508]	1972	optInt,
	1973	"vsp_bsp_term_min_rays=",
	1974	"-1");
[445]	1975
[469]	1976	RegisterOption("VspBspTree.Termination.ct_div_ci",
[508]	1977	optFloat,
	1978	"vsp_bsp_term_ct_div_ci=",
	1979	"0.0");
[445]	1980
[469]	1981	RegisterOption("VspBspTree.Termination.maxDepth",
[508]	1982	optInt,
	1983	"vsp_bsp_term_max_depth=",
[1134]	1984	"50");
[445]	1985
[469]	1986	RegisterOption("VspBspTree.Termination.AxisAligned.maxCostRatio",
[482]	1987	optFloat,
[666]	1988	"vsp_bsp_term_axis_aligned_max_cost_ratio=",
[482]	1989	"1.5");
[445]	1990
[612]	1991	RegisterOption("VspBspTree.useCostHeuristics",
	1992	optBool,
[666]	1993	"vsp_bsp_use_cost_heuristics=",
[612]	1994	"false");
	1995
[478]	1996	RegisterOption("VspBspTree.Termination.maxViewCells",
[482]	1997	optInt,
[666]	1998	"vsp_bsp_term_max_view_cells=",
[744]	1999	"10000");
[478]	2000
[472]	2001	RegisterOption("VspBspTree.Termination.maxCostRatio",
	2002	optFloat,
[666]	2003	"vsp_bsp_term_max_cost_ratio=",
[472]	2004	"1.5");
[445]	2005
[472]	2006	RegisterOption("VspBspTree.Termination.missTolerance",
[997]	2007	optInt,
	2008	"vsp_bsp_term_miss_tolerance=",
	2009	"4");
	2010
[469]	2011	RegisterOption("VspBspTree.splitPlaneStrategy",
[1134]	2012	optInt,
[508]	2013	"vsp_bsp_split_method=",
[1134]	2014	"1026");
[448]	2015
[469]	2016	RegisterOption("VspBspTree.maxPolyCandidates",
[508]	2017	optInt,
	2018	"vsp_bsp_max_poly_candidates=",
	2019	"20");
[1134]	2020
[469]	2021	RegisterOption("VspBspTree.maxRayCandidates",
[508]	2022	optInt,
	2023	"vsp_bsp_max_plane_candidates=",
	2024	"20");
[469]	2025
	2026	RegisterOption("VspBspTree.maxTests",
[508]	2027	optInt,
	2028	"vsp_bsp_max_tests=",
	2029	"5000");
[469]	2030
	2031	RegisterOption("VspBspTree.Construction.samples",
[508]	2032	optInt,
[673]	2033	"vsp_bsp_construction_samples=",
[508]	2034	"100000");
[469]	2035
[801]	2036	RegisterOption("VspBspTree.Construction.minBand",
	2037	optFloat,
	2038	"vsp_bsp_construction_min_band=",
[1074]	2039	"0.01");
[801]	2040
	2041	RegisterOption("VspBspTree.Construction.maxBand",
	2042	optFloat,
[1147]	2043	"vsp_bsp_construction_max_band=",
[1074]	2044	"0.99");
[801]	2045
[822]	2046	RegisterOption("VspBspTree.Construction.useDrivingAxisForMaxCost",
	2047	optBool,
	2048	"vsp_bsp_construction_use_drivingaxis_for_maxcost=",
	2049	"false");
	2050
[469]	2051	RegisterOption("VspBspTree.Construction.epsilon",
[508]	2052	optFloat,
[1023]	2053	"vsp_bsp_construction_epsilon=",
[508]	2054	"0.002");
[469]	2055
	2056	RegisterOption("VspBspTree.Visualization.exportSplits",
[508]	2057	optBool,
	2058	"vsp_bsp_visualization.export_splits",
	2059	"false");
	2060
[485]	2061	RegisterOption("VspBspTree.splitUseOnlyDrivingAxis",
[508]	2062	optBool,
[667]	2063	"vsp_bsp_split_only_driving_axis=",
[508]	2064	"false");
	2065
[607]	2066	RegisterOption("VspBspTree.usePolygonSplitIfAvailable",
	2067	optBool,
	2068	"vsp_bsp_usePolygonSplitIfAvailable=",
[611]	2069	"false");
[607]	2070
[508]	2071	RegisterOption("VspBspTree.Termination.AxisAligned.minRays",
	2072	optInt,
	2073	"bsp_term_axis_aligned_min_rays=",
[1134]	2074	"0");
[492]	2075
[508]	2076	RegisterOption("VspBspTree.Termination.AxisAligned.maxRayContribution",
	2077	optFloat,
	2078	"bsp_term_axis_aligned_min_rays=",
[1134]	2079	"2");
[508]	2080
[676]	2081	RegisterOption("VspBspTree.Factor.leastRaySplits",
	2082	optFloat,
	2083	"vsp_bsp_factor_least_ray_splits=",
	2084	"1.0");
	2085
	2086	RegisterOption("VspBspTree.Factor.balancedRays",
	2087	optFloat,
	2088	"vsp_bsp_factor_balanced_rays=",
	2089	"1.0");
	2090
	2091	RegisterOption("VspBspTree.Factor.pvs",
	2092	optFloat,
	2093	"vsp_bsp_factor_pvs=",
	2094	"1.0");
[664]	2095
[580]	2096	RegisterOption("VspBspTree.Construction.renderCostWeight",
[478]	2097	optFloat,
[1002]	2098	"vsp_bsp_post_process_render_cost_weight=",
[1134]	2099	"1.0");
[478]	2100
[1020]	2101	RegisterOption("VspBspTree.Construction.renderCostDecreaseWeight",
	2102	optFloat,
[1121]	2103	"vsp_bsp_construction_render_cost_decrease_weight=",
[1020]	2104	"0.99");
	2105
[486]	2106	RegisterOption("VspBspTree.Construction.randomize",
	2107	optBool,
	2108	"vsp_bsp_construction_randomize=",
	2109	"false");
[508]	2110
[663]	2111	RegisterOption("VspBspTree.simulateOctree",
	2112	optBool,
	2113	"vsp_bsp_simulate_octree=",
	2114	"false");
	2115
[735]	2116	RegisterOption("VspBspTree.nodePriorityQueueType",
	2117	optInt,
	2118	"vsp_bsp_node_queue_type=",
	2119	"0");
[664]	2120
	2121	RegisterOption("VspBspTree.useRandomAxis",
	2122	optBool,
	2123	"-vsp_bsp_use_random_axis=",
	2124	"false");
	2125
[508]	2126	RegisterOption("VspBspTree.maxTotalMemory",
	2127	optFloat,
	2128	"vsp_bsp_max_total_mem=",
	2129	"60.0");
	2130
	2131	RegisterOption("VspBspTree.maxStaticMemory",
	2132	optFloat,
	2133	"vsp_bsp_max_static_mem=",
	2134	"8.0");
[564]	2135
[1023]	2136
	2137
[1027]	2138	/***************************************************************************/
	2139	/* View space partition tree related options */
	2140	/***************************************************************************/
[1023]	2141
[580]	2142
[1027]	2143	RegisterOption("VspTree.Construction.samples",
	2144	optInt,
	2145	"vsp_construction_samples=",
	2146	"10000");
	2147
[1121]	2148
	2149	RegisterOption("VspTree.Construction.renderCostDecreaseWeight",
	2150	optFloat,
	2151	"vsp_construction_render_cost_decrease_weight=",
	2152	"0.99");
	2153
[1023]	2154	RegisterOption("VspTree.Termination.maxDepth",
	2155	optInt,
	2156	"vsp_term_max_depth=",
	2157	"100");
	2158
	2159	RegisterOption("VspTree.Termination.minRays",
	2160	optInt,
	2161	"vsp_term_min_rays=",
	2162	"-1");
	2163
	2164
	2165	RegisterOption("VspTree.Termination.minPvs",
	2166	optInt,
	2167	"vsp_term_min_pvs=",
	2168	"20");
	2169
	2170	RegisterOption("VspTree.Termination.minProbability",
	2171	optFloat,
	2172	"vsp_term_min_probability=",
	2173	"0.001");
	2174
	2175	RegisterOption("VspTree.Termination.maxRayContribution",
	2176	optFloat,
	2177	"vsp_term_ray_contribution=",
	2178	"0.9");
	2179
	2180	RegisterOption("VspTree.Termination.maxCostRatio",
	2181	optFloat,
	2182	"vsp_term_max_cost_ratio=",
	2183	"1.5");
	2184
	2185	RegisterOption("VspTree.Termination.maxViewCells",
	2186	optInt,
	2187	"vsp_term_max_view_cells=",
	2188	"10000");
[564]	2189
[1023]	2190
	2191	RegisterOption("VspTree.Termination.missTolerance",
	2192	optInt,
	2193	"vsp_term_miss_tolerance=",
	2194	"4");
	2195
	2196	RegisterOption("VspTree.Termination.minGlobalCostRatio",
	2197	optFloat,
	2198	"vsp_term_min_global_cost_ratio=",
	2199	"0.0001");
	2200
	2201	RegisterOption("VspTree.Termination.globalCostMissTolerance",
	2202	optInt,
	2203	"vsp_term_global_cost_miss_tolerance=",
	2204	"4");
	2205
	2206	RegisterOption("VspTree.Termination.ct_div_ci",
	2207	optFloat,
	2208	"vsp_term_ct_div_ci=",
	2209	"0.0");
	2210
	2211	RegisterOption("VspTree.Construction.epsilon",
	2212	optFloat,
	2213	"vsp_construction_epsilon=",
	2214	"0.002");
	2215
	2216	RegisterOption("VspTree.splitUseOnlyDrivingAxis",
	2217	optBool,
	2218	"vsp_split_only_driving_axis=",
	2219	"false");
	2220
	2221	RegisterOption("VspTree.maxStaticMemory",
	2222	optFloat,
	2223	"vsp_max_static_mem=",
	2224	"8.0");
	2225
	2226	RegisterOption("VspTree.useCostHeuristics",
	2227	optBool,
	2228	"vsp_use_cost_heuristics=",
	2229	"false");
	2230
	2231	RegisterOption("VspTree.simulateOctree",
	2232	optBool,
	2233	"vsp_simulate_octree=",
	2234	"false");
	2235
	2236	RegisterOption("VspTree.Construction.randomize",
	2237	optBool,
	2238	"vsp_construction_randomize=",
	2239	"false");
	2240
	2241	RegisterOption("VspTree.subdivisionStats",
	2242	optString,
	2243	"vsp_subdivision_stats=",
	2244	"vspSubdivisionStats.log");
	2245
	2246	RegisterOption("VspTree.Construction.minBand",
	2247	optFloat,
	2248	"vsp_construction_min_band=",
[1074]	2249	"0.01");
[1023]	2250
	2251	RegisterOption("VspTree.Construction.maxBand",
	2252	optFloat,
[1074]	2253	"vsp_construction_max_band=",
	2254	"0.99");
[1106]	2255
[1149]	2256	RegisterOption("VspTree.maxTests",
	2257	optInt,
	2258	"vsp_max_tests=",
[1161]	2259	"5000");
[1143]	2260
	2261
[1074]	2262
[1288]	2263	/***********************************************************************/
	2264	/* Object space partition tree related options */
	2265	/***********************************************************************/
[1143]	2266
[1294]	2267
[1106]	2268	RegisterOption("OspTree.Construction.randomize",
[1288]	2269	optBool,
	2270	"osp_construction_randomize=",
	2271	"false");
[1106]	2272
	2273	RegisterOption("OspTree.Termination.maxDepth",
	2274	optInt,
	2275	"osp_term_max_depth=",
	2276	"30");
	2277
	2278	RegisterOption("OspTree.Termination.maxLeaves",
	2279	optInt,
	2280	"osp_term_max_leaves=",
	2281	"1000");
	2282
	2283	RegisterOption("OspTree.Termination.minObjects",
	2284	optInt,
	2285	"osp_term_min_objects=",
	2286	"1");
	2287
	2288	RegisterOption("OspTree.Termination.minProbability",
	2289	optFloat,
	2290	"osp_term_min_objects=",
[1288]	2291	"0.00001");
[1106]	2292
	2293	RegisterOption("OspTree.Termination.missTolerance",
	2294	optInt,
	2295	"osp_term_miss_tolerance=",
[1288]	2296	"8");
[1106]	2297
	2298	RegisterOption("OspTree.Termination.maxCostRatio",
	2299	optFloat,
	2300	"osp_term_max_cost_ratio=",
	2301	"0.99");
	2302
	2303	RegisterOption("OspTree.Termination.minGlobalCostRatio",
	2304	optFloat,
	2305	"osp_term_min_global_cost_ratio=",
	2306	"0.00001");
	2307
	2308	RegisterOption("OspTree.Termination.globalCostMissTolerance",
	2309	optInt,
	2310	"osp_term_global_cost_miss_tolerance=",
	2311	"4");
	2312
	2313	RegisterOption("OspTree.Termination.ct_div_ci",
	2314	optFloat,
	2315	"osp_term_ct_div_ci=",
	2316	"0");
	2317
	2318	RegisterOption("OspTree.Construction.epsilon",
[1288]	2319	optFloat,
	2320	"osp_construction_epsilon=",
	2321	"0.00001");
[1106]	2322
	2323	// if only the driving axis is used for axis aligned split
	2324	RegisterOption("OspTree.splitUseOnlyDrivingAxis",
[1288]	2325	optBool,
	2326	"osp_split_only_driving_axis=",
	2327	"false");
[1106]	2328
	2329	RegisterOption("OspTree.maxStaticMemory",
[1288]	2330	optFloat,
	2331	"osp_max_static_mem=",
	2332	"8.0");
[1106]	2333
	2334	RegisterOption("OspTree.useCostHeuristics",
[1288]	2335	optBool,
	2336	"osp_use_cost_heuristics=",
	2337	"true");
[1106]	2338
	2339	RegisterOption("OspTree.subdivisionStats",
	2340	optString,
	2341	"osp_subdivision_stats=",
	2342	"ospSubdivisionStats.log");
	2343
	2344	RegisterOption("OspTree.Construction.splitBorder",
	2345	optFloat,
	2346	"osp_construction_split_border=",
	2347	"0.01");
	2348
[1121]	2349	RegisterOption("OspTree.Construction.renderCostDecreaseWeight",
[1288]	2350	optFloat,
	2351	"osp_construction_render_cost_decrease_weight=",
	2352	"0.99");
[1106]	2353
	2354
[1288]	2355
[1297]	2356	/**********************************************************************/
	2357	/* Bounding Volume Hierarchy related options */
	2358	/**********************************************************************/
[1288]	2359
	2360	RegisterOption("BvHierarchy.Construction.randomize",
	2361	optBool,
	2362	"bvh_construction_randomize=",
	2363	"false");
	2364
	2365	RegisterOption("BvHierarchy.Termination.maxDepth",
	2366	optInt,
	2367	"bvh_term_max_depth=",
	2368	"30");
	2369
	2370	RegisterOption("BvHierarchy.Termination.maxLeaves",
	2371	optInt,
	2372	"bvh_term_max_leaves=",
	2373	"1000");
	2374
	2375	RegisterOption("BvHierarchy.Termination.minObjects",
	2376	optInt,
	2377	"bvh_term_min_objects=",
	2378	"1");
	2379
	2380	RegisterOption("BvHierarchy.Termination.minProbability",
	2381	optFloat,
	2382	"bvh_term_min_objects=",
	2383	"0.00001");
	2384
[1370]	2385	RegisterOption("BvHierarchy.Termination.minRays",
	2386	optInt,
	2387	"bvh_term_min_rays=",
	2388	"0");
	2389
[1288]	2390	RegisterOption("BvHierarchy.Termination.missTolerance",
	2391	optInt,
	2392	"osp_term_miss_tolerance=",
	2393	"8");
	2394
	2395	RegisterOption("BvHierarchy.Termination.maxCostRatio",
	2396	optFloat,
	2397	"bvh_term_max_cost_ratio=",
	2398	"0.99");
	2399
	2400	RegisterOption("BvHierarchy.Termination.minGlobalCostRatio",
	2401	optFloat,
	2402	"bvh_term_min_global_cost_ratio=",
	2403	"0.00001");
	2404
	2405	RegisterOption("BvHierarchy.Termination.globalCostMissTolerance",
	2406	optInt,
	2407	"bvh_term_global_cost_miss_tolerance=",
	2408	"4");
	2409
	2410	// if only the driving axis is used for axis aligned split
	2411	RegisterOption("BvHierarchy.splitUseOnlyDrivingAxis",
	2412	optBool,
	2413	"bvh_split_only_driving_axis=",
	2414	"false");
	2415
	2416	RegisterOption("BvHierarchy.maxStaticMemory",
	2417	optFloat,
	2418	"bvh_max_static_mem=",
	2419	"8.0");
	2420
	2421	RegisterOption("BvHierarchy.useCostHeuristics",
	2422	optBool,
	2423	"bvh_use_cost_heuristics=",
	2424	"true");
	2425
	2426	RegisterOption("BvHierarchy.subdivisionStats",
[1174]	2427	optString,
[1288]	2428	"bvh_subdivision_stats=",
	2429	"bvhSubdivisionStats.log");
[1174]	2430
[1288]	2431	RegisterOption("BvHierarchy.Construction.renderCostDecreaseWeight",
	2432	optFloat,
	2433	"bvh_construction_render_cost_decrease_weight=",
	2434	"0.99");
[1359]	2435
	2436	RegisterOption("BvHierarchy.Construction.useGlobalSorting",
	2437	optBool,
	2438	"bvh_construction_use_global_sorting=",
[1489]	2439	"true");
[1288]	2440
[1359]	2441
	2442	/*******************************************************************/
	2443	/* Hierarchy Manager related options */
	2444	/*******************************************************************/
[1288]	2445
	2446	RegisterOption("Hierarchy.subdivisionStats",
	2447	optString,
	2448	"hierarchy_subdivision_stats=",
	2449	"hierarchySubdivisionStats.log");
	2450
	2451	RegisterOption("Hierarchy.type",
	2452	optString,
	2453	"hierarchy_type=",
	2454	"bvh");
	2455
	2456	RegisterOption("Hierarchy.Termination.minGlobalCostRatio",
	2457	optFloat,
	2458	"hierarchy_term_min_global_cost_ratio=",
[1444]	2459	"0.000000001");
[1288]	2460
	2461	RegisterOption("Hierarchy.Termination.globalCostMissTolerance",
	2462	optInt,
	2463	"hierarchy_term_global_cost_miss_tolerance=",
	2464	"4");
	2465
	2466	RegisterOption("Hierarchy.Termination.maxLeaves",
	2467	optInt,
	2468	"hierarchy_term_max_leaves=",
	2469	"1000");
	2470
[1293]	2471	RegisterOption("Hierarchy.Construction.type",
	2472	optInt,
	2473	"hierarchy_construction_type=",
	2474	"0");
	2475
[1311]	2476	RegisterOption("Hierarchy.Construction.minDepthForOsp",
	2477	optInt,
	2478	"hierarchy_construction_min_depth_for_osp=",
	2479	"-1");
	2480
[1370]	2481	RegisterOption("Hierarchy.Construction.startWithObjectSpace",
	2482	optBool,
	2483	"hierarchy_construction_start_with_osp=",
	2484	"true");
	2485
[1314]	2486	RegisterOption("Hierarchy.Construction.repairQueue",
	2487	optBool,
	2488	"hierarchy_construction_repair_queue=",
	2489	"true");
[1311]	2490
[1370]	2491	RegisterOption("Hierarchy.Construction.minDepthForVsp",
	2492	optInt,
	2493	"hierarchy_construction_min_depth_for_vsp=",
	2494	"-1");
[1359]	2495
[1449]	2496	RegisterOption("Hierarchy.Construction.useMultiLevelConstruction",
	2497	optBool,
	2498	"hierarchy_construction_use_multilevel_construction=",
	2499	"false");
	2500
[1458]	2501	/////////////////////////////////////////////////////////////////
[372]	2502	}
	2503
	2504	void
	2505	Environment::SetStaticOptions()
	2506	{
	2507
	2508	// get Global option values
	2509	GetRealValue("Limits.threshold", Limits::Threshold);
	2510	GetRealValue("Limits.small", Limits::Small);
	2511	GetRealValue("Limits.infinity", Limits::Infinity);
	2512
	2513
	2514	}
	2515
[938]	2516	bool
[492]	2517	Environment::Parse(const int argc, char **argv, bool useExePath)
[372]	2518	{
[938]	2519	bool result = true;
[372]	2520	// Read the names of the scene, environment and output files
	2521	ReadCmdlineParams(argc, argv, "");
	2522
	2523	char *envFilename = new char[128];
	2524
	2525	char filename[64];
	2526
	2527	// Get the environment file name
	2528	if (!GetParam(' ', 0, filename)) {
	2529	// user didn't specified environment file explicitly, so
[1199]	2530	strcpy(filename, "default.env");
[372]	2531	}
	2532
	2533	if (useExePath) {
	2534	char *path = GetPath(argv[0]);
	2535	if (*path != 0)
	2536	sprintf(envFilename, "%s/%s", path, filename);
	2537	else
	2538	strcpy(envFilename, filename);
	2539
	2540	delete path;
	2541	}
	2542	else
	2543	strcpy(envFilename, filename);
	2544
	2545
	2546	// Now it's time to read in environment file.
	2547	if (!ReadEnvFile(envFilename)) {
	2548	// error - bad input file name specified ?
	2549	cerr<<"Error parsing environment file "<<envFilename<<endl;
[938]	2550	result = false;
[372]	2551	}
	2552	delete envFilename;
	2553
	2554	// Parse the command line; options given on the command line subsume
	2555	// stuff specified in the input environment file.
	2556	ParseCmdline(argc, argv, 0);
	2557
	2558	SetStaticOptions();
	2559
	2560	// Check for request for help
	2561	if (CheckForSwitch(argc, argv, '?')) {
	2562	PrintUsage(cout);
	2563	exit(0);
	2564	}
[938]	2565
	2566	return true;
[372]	2567	}
[860]	2568
[878]	2569	}

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

Download in other formats: