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 |
|
---|
23 | Environment *environment = NULL;
|
---|
24 |
|
---|
25 | Environment::~Environment()
|
---|
26 | {
|
---|
27 | int i, j;
|
---|
28 |
|
---|
29 | // delete the params structure
|
---|
30 | for (i = 0; i < numParams; i++) {
|
---|
31 | for (j = 0; j < paramRows; j++)
|
---|
32 | if (params[i][j] != NULL)
|
---|
33 | delete[] params[i][j];
|
---|
34 | if (params[i] != NULL)
|
---|
35 | delete[] params[i];
|
---|
36 | }
|
---|
37 |
|
---|
38 | if (params != NULL)
|
---|
39 | delete[] params;
|
---|
40 |
|
---|
41 | // delete the options structure
|
---|
42 | if (options != NULL)
|
---|
43 | delete[] options;
|
---|
44 |
|
---|
45 | if (optionalParams != NULL)
|
---|
46 | delete optionalParams;
|
---|
47 | }
|
---|
48 |
|
---|
49 | bool
|
---|
50 | Environment::CheckForSwitch(const int argc,
|
---|
51 | char **argv,
|
---|
52 | const char swtch) const
|
---|
53 | {
|
---|
54 | for (int i = 1; i < argc; i++)
|
---|
55 | if ((argv[i][0] == '-') && (argv[i][1] == swtch))
|
---|
56 | return true;
|
---|
57 | return false;
|
---|
58 | }
|
---|
59 |
|
---|
60 | bool
|
---|
61 | Environment::CheckType(const char *value,
|
---|
62 | const EOptType type) const
|
---|
63 | {
|
---|
64 | char *s, *t, *u;
|
---|
65 |
|
---|
66 | switch (type) {
|
---|
67 | case optInt: {
|
---|
68 | strtol(value, &t, 10);
|
---|
69 | if (value + strlen(value) != t)
|
---|
70 | return false;
|
---|
71 | else
|
---|
72 | return true;
|
---|
73 | }
|
---|
74 | case optFloat: {
|
---|
75 | strtod(value, &t);
|
---|
76 | if (value + strlen(value) != t)
|
---|
77 | return false;
|
---|
78 | else
|
---|
79 | return true;
|
---|
80 | }
|
---|
81 | case optBool: {
|
---|
82 | if (!strcasecmp(value, "true") ||
|
---|
83 | !strcasecmp(value, "false") ||
|
---|
84 | !strcasecmp(value, "YES") ||
|
---|
85 | !strcasecmp(value, "NO") ||
|
---|
86 | !strcmp(value, "+") ||
|
---|
87 | !strcmp(value, "-") ||
|
---|
88 | !strcasecmp(value, "ON") ||
|
---|
89 | !strcasecmp(value, "OFF"))
|
---|
90 | return true;
|
---|
91 | return false;
|
---|
92 | }
|
---|
93 | case optVector:{
|
---|
94 | strtod(value, &s);
|
---|
95 | if (*s == ' ' || *s == '\t') {
|
---|
96 | while (*s == ' ' || *s == '\t')
|
---|
97 | s++;
|
---|
98 | if (*s != ',')
|
---|
99 | s--;
|
---|
100 | }
|
---|
101 | if ((*s != ',' && *s != ' ' && *s != '\t') || value == s)
|
---|
102 | return false;
|
---|
103 | t = s;
|
---|
104 | strtod(s + 1, &u);
|
---|
105 | if (*u == ' ' || *u == '\t') {
|
---|
106 | while (*u == ' ' || *u == '\t')
|
---|
107 | u++;
|
---|
108 | if (*u != ',')
|
---|
109 | u--;
|
---|
110 | }
|
---|
111 | if ((*u != ',' && *s != ' ' && *s != '\t') || t == u)
|
---|
112 | return false;
|
---|
113 | t = u;
|
---|
114 | strtod(u + 1, &s);
|
---|
115 | if (t == s || value + strlen(value) != s)
|
---|
116 | return false;
|
---|
117 | return true;
|
---|
118 | }
|
---|
119 | case optString: {
|
---|
120 | return true;
|
---|
121 | }
|
---|
122 | default: {
|
---|
123 | Debug << "Internal error: Unknown type of option.\n" << flush;
|
---|
124 | exit(1);
|
---|
125 | }
|
---|
126 | }
|
---|
127 | return false;
|
---|
128 | }
|
---|
129 |
|
---|
130 | void
|
---|
131 | Environment::ReadCmdlineParams(const int argc,
|
---|
132 | char **argv,
|
---|
133 | const char *optParams)
|
---|
134 | {
|
---|
135 | int i;
|
---|
136 |
|
---|
137 | // Make sure we are called for the first time
|
---|
138 | if (optionalParams != NULL)
|
---|
139 | return;
|
---|
140 |
|
---|
141 | numParams = (int)strlen(optParams) + 1;
|
---|
142 | optionalParams = new char[numParams];
|
---|
143 | strcpy(optionalParams, optParams);
|
---|
144 |
|
---|
145 | // First, count all non-optional parameters on the command line
|
---|
146 | for (i = 1; i < argc; i++)
|
---|
147 | if (argv[i][0] != '-')
|
---|
148 | paramRows++;
|
---|
149 |
|
---|
150 | // if there is no non-optional parameter add a default one...
|
---|
151 | if (paramRows == 0)
|
---|
152 | paramRows = 1;
|
---|
153 |
|
---|
154 | // allocate and initialize the table for parameters
|
---|
155 | params = new char **[numParams];
|
---|
156 | for (i = 0; i < numParams; i++) {
|
---|
157 | params[i] = new char *[paramRows];
|
---|
158 | for (int j = 0; j < paramRows; j++)
|
---|
159 | params[i][j] = NULL;
|
---|
160 | }
|
---|
161 | // Now read all non-optional and optional parameters into the table
|
---|
162 | curRow = -1;
|
---|
163 | for (i = 1; i < argc; i++) {
|
---|
164 | if (argv[i][0] != '-') {
|
---|
165 | // non-optional parameter encountered
|
---|
166 | curRow++;
|
---|
167 | params[0][curRow] = new char[strlen(argv[i]) + 1];
|
---|
168 | strcpy(params[0][curRow], argv[i]);
|
---|
169 | }
|
---|
170 | else {
|
---|
171 | // option encountered
|
---|
172 | char *t = strchr(optionalParams, argv[i][1]);
|
---|
173 | if (t != NULL) {
|
---|
174 | // this option is optional parameter
|
---|
175 | int index = t - optionalParams + 1;
|
---|
176 | if (curRow < 0) {
|
---|
177 | // it's a global parameter
|
---|
178 | for (int j = 0; j < paramRows; j++) {
|
---|
179 | params[index][j] = new char[strlen(argv[i] + 2) + 1];
|
---|
180 | strcpy(params[index][j], argv[i] + 2);
|
---|
181 | }
|
---|
182 | }
|
---|
183 | else {
|
---|
184 | // it's a scene parameter
|
---|
185 | if (params[index][curRow] != NULL) {
|
---|
186 | delete[] params[index][curRow];
|
---|
187 | }
|
---|
188 | params[index][curRow] = new char[strlen(argv[i] + 2) + 1];
|
---|
189 | strcpy(params[index][curRow], argv[i] + 2);
|
---|
190 | }
|
---|
191 | }
|
---|
192 | }
|
---|
193 | }
|
---|
194 | curRow = 0;
|
---|
195 |
|
---|
196 | #ifdef _DEBUG_PARAMS
|
---|
197 | // write out the parameter table
|
---|
198 | cerr << "Parameter table for " << numParams << " columns and "
|
---|
199 | << paramRows << " rows:\n";
|
---|
200 | for (int j = 0; j < paramRows; j++) {
|
---|
201 | for (i = 0; i < numParams; i++) {
|
---|
202 | if (params[i][j] != NULL)
|
---|
203 | cerr << params[i][j];
|
---|
204 | else
|
---|
205 | cerr << "NULL";
|
---|
206 | cerr << "\t";
|
---|
207 | }
|
---|
208 | cerr << "\n";
|
---|
209 | }
|
---|
210 | cerr << "Params done.\n" << flush;
|
---|
211 | #endif // _DEBUG_PARAMS
|
---|
212 | }
|
---|
213 |
|
---|
214 | bool
|
---|
215 | Environment::GetParam(const char name,
|
---|
216 | const int index,
|
---|
217 | char *value) const
|
---|
218 | {
|
---|
219 | int column;
|
---|
220 |
|
---|
221 | if (index >= paramRows || index < 0)
|
---|
222 | return false;
|
---|
223 | if (name == ' ')
|
---|
224 | column = 0;
|
---|
225 | else {
|
---|
226 | char *t = strchr(optionalParams, name);
|
---|
227 |
|
---|
228 | if (t == NULL)
|
---|
229 | return false;
|
---|
230 | column = t - optionalParams + 1;
|
---|
231 | }
|
---|
232 |
|
---|
233 | if (params[column][index] == NULL)
|
---|
234 | return false;
|
---|
235 | // value = new char[strlen(params[column][index]) + 1];
|
---|
236 | strcpy(value, params[column][index]);
|
---|
237 | return true;
|
---|
238 | }
|
---|
239 |
|
---|
240 | void
|
---|
241 | Environment::RegisterOption(const char *name,
|
---|
242 | const EOptType type,
|
---|
243 | const char *abbrev,
|
---|
244 | const char *defValue)
|
---|
245 | {
|
---|
246 | int i;
|
---|
247 |
|
---|
248 | // make sure this option was not yet registered
|
---|
249 | for (i = 0; i < numOptions; i++)
|
---|
250 | if (!strcmp(name, options[i].name)) {
|
---|
251 | Debug << "Error: Option " << name << " registered twice.\n";
|
---|
252 | exit(1);
|
---|
253 | }
|
---|
254 | // make sure we have enough room in memory
|
---|
255 | if (numOptions >= maxOptions) {
|
---|
256 | Debug << "Error: Too many options. Try enlarge the maxOptions "
|
---|
257 | << "definition.\n";
|
---|
258 | exit(1);
|
---|
259 | }
|
---|
260 |
|
---|
261 | // make sure the abbreviation doesn't start with 'D'
|
---|
262 | if (abbrev != NULL && (abbrev[0] == 'D' )) {
|
---|
263 | Debug << "Internal error: reserved switch " << abbrev
|
---|
264 | << " used as an abbreviation.\n";
|
---|
265 | exit(1);
|
---|
266 | }
|
---|
267 | // new option
|
---|
268 | options[numOptions].type = type;
|
---|
269 | options[numOptions].name = strdup(name);
|
---|
270 | // assign abbreviation, if requested
|
---|
271 | if (abbrev != NULL) {
|
---|
272 | options[numOptions].abbrev = strdup(abbrev);
|
---|
273 | }
|
---|
274 | // assign default value, if requested
|
---|
275 | if (defValue != NULL) {
|
---|
276 | options[numOptions].defaultValue = strdup(defValue);
|
---|
277 | if (!CheckType(defValue, type)) {
|
---|
278 | Debug << "Internal error: Inconsistent type and default value in option "
|
---|
279 | << name << ".\n";
|
---|
280 | exit(1);
|
---|
281 | }
|
---|
282 | }
|
---|
283 | // new option registered
|
---|
284 | numOptions++;
|
---|
285 | }
|
---|
286 |
|
---|
287 | bool
|
---|
288 | Environment::OptionPresent(const char *name) const
|
---|
289 | {
|
---|
290 | bool found = false;
|
---|
291 | int i;
|
---|
292 |
|
---|
293 | for (i = 0; i < numOptions; i++)
|
---|
294 | if (!strcmp(options[i].name, name)) {
|
---|
295 | found = true;
|
---|
296 | break;
|
---|
297 | }
|
---|
298 | if (!found) {
|
---|
299 | Debug << "Internal error: Option " << name << " not registered.\n" << flush;
|
---|
300 | exit(1);
|
---|
301 | }
|
---|
302 | if (options[i].value != NULL || options[i].defaultValue != NULL)
|
---|
303 | return true;
|
---|
304 | else
|
---|
305 | return false;
|
---|
306 | }
|
---|
307 |
|
---|
308 | int
|
---|
309 | Environment::FindOption(const char *name,
|
---|
310 | const bool isFatal) const
|
---|
311 | {
|
---|
312 | int i;
|
---|
313 | bool found = false;
|
---|
314 | // is this option registered ?
|
---|
315 | for (i = 0; i < numOptions; i++)
|
---|
316 | if (!strcmp(options[i].name, name)) {
|
---|
317 | found = true;
|
---|
318 | break;
|
---|
319 | }
|
---|
320 | if (!found) {
|
---|
321 | // no registration found
|
---|
322 | Debug << "Internal error: Required option " << name
|
---|
323 | << " not registered.\n" << flush;
|
---|
324 | exit(1);
|
---|
325 | }
|
---|
326 | if (options[i].value == NULL && options[i].defaultValue == NULL)
|
---|
327 | // this option was not initialised to some value
|
---|
328 | if (isFatal) {
|
---|
329 | Debug << "Error: Required option " << name << " not found.\n" << flush;
|
---|
330 | exit(1);
|
---|
331 | }
|
---|
332 | else {
|
---|
333 | Debug << "Error: Required option " << name << " not found.\n" << flush;
|
---|
334 | return -1;
|
---|
335 | }
|
---|
336 | return i;
|
---|
337 | }
|
---|
338 |
|
---|
339 | bool
|
---|
340 | Environment::GetIntValue(const char *name,
|
---|
341 | int &value,
|
---|
342 | const bool isFatal) const
|
---|
343 | {
|
---|
344 | int i = FindOption(name, isFatal);
|
---|
345 |
|
---|
346 | if (i<0)
|
---|
347 | return false;
|
---|
348 |
|
---|
349 | if (options[i].value != NULL) {
|
---|
350 | // option was explicitly specified
|
---|
351 | value = strtol(options[i].value, NULL, 10);
|
---|
352 | } else {
|
---|
353 | // option was not read, so use the default
|
---|
354 | value = strtol(options[i].defaultValue, NULL, 10);
|
---|
355 | }
|
---|
356 |
|
---|
357 | return true;
|
---|
358 | }
|
---|
359 |
|
---|
360 | bool
|
---|
361 | Environment::GetDoubleValue(const char *name,
|
---|
362 | double &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 = strtod(options[i].value, NULL);
|
---|
373 | } else {
|
---|
374 | // option was not read, so use the default
|
---|
375 | value = strtod(options[i].defaultValue, NULL);
|
---|
376 | }
|
---|
377 | return true;
|
---|
378 | }
|
---|
379 |
|
---|
380 | bool
|
---|
381 | Environment::GetRealValue(const char *name,
|
---|
382 | Real &value,
|
---|
383 | const bool isFatal) const
|
---|
384 | {
|
---|
385 | int i = FindOption(name, isFatal);
|
---|
386 |
|
---|
387 | if (i<0)
|
---|
388 | return false;
|
---|
389 |
|
---|
390 | if (options[i].value != NULL) {
|
---|
391 | // option was explicitly specified
|
---|
392 | value = (Real)strtod(options[i].value, NULL);
|
---|
393 | } else {
|
---|
394 | // option was not read, so use the default
|
---|
395 | value = (Real)strtod(options[i].defaultValue, NULL);
|
---|
396 | }
|
---|
397 | return true;
|
---|
398 | }
|
---|
399 |
|
---|
400 | bool
|
---|
401 | Environment::GetFloatValue(const char *name,
|
---|
402 | float &value,
|
---|
403 | const bool isFatal) const
|
---|
404 | {
|
---|
405 | int i = FindOption(name, isFatal);
|
---|
406 |
|
---|
407 | if (i<0)
|
---|
408 | return false;
|
---|
409 |
|
---|
410 | if (options[i].value != NULL) {
|
---|
411 | // option was explicitly specified
|
---|
412 | value = (float)strtod(options[i].value, NULL);
|
---|
413 | } else {
|
---|
414 | // option was not read, so use the default
|
---|
415 | value = (float)strtod(options[i].defaultValue, NULL);
|
---|
416 | }
|
---|
417 | return true;
|
---|
418 | }
|
---|
419 |
|
---|
420 | bool
|
---|
421 | Environment::GetBool(const char *name,
|
---|
422 | const bool isFatal) const
|
---|
423 | {
|
---|
424 | bool ret;
|
---|
425 | if (GetBoolValue(name, ret, isFatal))
|
---|
426 | return ret;
|
---|
427 | else
|
---|
428 | return false;
|
---|
429 | }
|
---|
430 |
|
---|
431 | bool
|
---|
432 | Environment::ParseBool(const char *name) const
|
---|
433 | {
|
---|
434 |
|
---|
435 | bool value = true;
|
---|
436 |
|
---|
437 | if (!strcasecmp(name, "false") ||
|
---|
438 | !strcasecmp(name, "NO") ||
|
---|
439 | !strcmp(name, "-") ||
|
---|
440 | !strcasecmp(name, "OFF"))
|
---|
441 | value = false;
|
---|
442 |
|
---|
443 | return value;
|
---|
444 | }
|
---|
445 |
|
---|
446 | void
|
---|
447 | Environment::ParseVector(const char *name, Vector3 &v) const
|
---|
448 | {
|
---|
449 | // option was not read, so use the default
|
---|
450 | char *s, *t;
|
---|
451 |
|
---|
452 | v.x = (Real)strtod(name, &s);
|
---|
453 | v.y = (Real)strtod(s + 1, &t);
|
---|
454 | v.z = (Real)strtod(t + 1, NULL);
|
---|
455 |
|
---|
456 | }
|
---|
457 |
|
---|
458 | bool
|
---|
459 | Environment::GetBoolValue(const char *name,
|
---|
460 | bool &value,
|
---|
461 | const bool isFatal) const
|
---|
462 | {
|
---|
463 | int i = FindOption(name, isFatal);
|
---|
464 |
|
---|
465 | if (i<0)
|
---|
466 | return false;
|
---|
467 |
|
---|
468 |
|
---|
469 | if (options[i].value != NULL)
|
---|
470 | value = ParseBool(options[i].value);
|
---|
471 | else
|
---|
472 | value = ParseBool(options[i].defaultValue);
|
---|
473 |
|
---|
474 | return true;
|
---|
475 | }
|
---|
476 |
|
---|
477 | bool
|
---|
478 | Environment::GetVectorValue(const char *name,
|
---|
479 | Vector3 &v,
|
---|
480 | const bool isFatal) const
|
---|
481 | {
|
---|
482 | int i = FindOption(name, isFatal);
|
---|
483 | if (i<0)
|
---|
484 | return false;
|
---|
485 |
|
---|
486 | if (options[i].value != NULL)
|
---|
487 |
|
---|
488 |
|
---|
489 | if (options[i].value != NULL) {
|
---|
490 | ParseVector(options[i].value, v);
|
---|
491 | }
|
---|
492 | else {
|
---|
493 | ParseVector(options[i].defaultValue, v);
|
---|
494 | }
|
---|
495 | return true;
|
---|
496 | }
|
---|
497 |
|
---|
498 | bool
|
---|
499 | Environment::GetStringValue(const char *name,
|
---|
500 | char *value,
|
---|
501 | const bool isFatal) const
|
---|
502 | {
|
---|
503 | int i = FindOption(name, isFatal);
|
---|
504 |
|
---|
505 | if (i<0)
|
---|
506 | return false;
|
---|
507 |
|
---|
508 |
|
---|
509 | if (options[i].value != NULL) {
|
---|
510 | // option was not read, so use the default
|
---|
511 | strcpy(value, options[i].value);
|
---|
512 | }
|
---|
513 | else {
|
---|
514 | // option was explicitly specified
|
---|
515 | strcpy(value, options[i].defaultValue);
|
---|
516 | }
|
---|
517 | return true;
|
---|
518 | }
|
---|
519 |
|
---|
520 | void
|
---|
521 | Environment::SetInt(const char *name, const int value)
|
---|
522 | {
|
---|
523 |
|
---|
524 | int i = FindOption(name);
|
---|
525 | if (i<0)
|
---|
526 | return;
|
---|
527 |
|
---|
528 | if (options[i].type == optInt) {
|
---|
529 | delete options[i].value;
|
---|
530 | options[i].value = new char[16];
|
---|
531 | sprintf(options[i].value, "%.15d", value);
|
---|
532 | }
|
---|
533 | else {
|
---|
534 | Debug << "Internal error: Trying to set non-integer option " << name
|
---|
535 | << " to integral value.\n" << flush;
|
---|
536 | exit(1);
|
---|
537 | }
|
---|
538 | }
|
---|
539 |
|
---|
540 | void
|
---|
541 | Environment::SetFloat(const char *name, const Real value)
|
---|
542 | {
|
---|
543 | int i = FindOption(name);
|
---|
544 | if (i<0)
|
---|
545 | return;
|
---|
546 |
|
---|
547 | if (options[i].type == optFloat) {
|
---|
548 | delete options[i].value;
|
---|
549 | options[i].value = new char[25];
|
---|
550 | sprintf(options[i].value, "%.15e", value);
|
---|
551 | }
|
---|
552 | else {
|
---|
553 | Debug << "Internal error: Trying to set non-Real option " << name
|
---|
554 | << " to Real value.\n" << flush;
|
---|
555 | exit(1);
|
---|
556 | }
|
---|
557 | }
|
---|
558 |
|
---|
559 | void
|
---|
560 | Environment::SetBool(const char *name, const bool value)
|
---|
561 | {
|
---|
562 | int i = FindOption(name);
|
---|
563 | if (i<0)
|
---|
564 | return;
|
---|
565 |
|
---|
566 | if (options[i].type == optBool) {
|
---|
567 | delete options[i].value;
|
---|
568 | options[i].value = new char[6];
|
---|
569 | if (value)
|
---|
570 | sprintf(options[i].value, "true");
|
---|
571 | else
|
---|
572 | sprintf(options[i].value, "false");
|
---|
573 | }
|
---|
574 | else {
|
---|
575 | Debug << "Internal error: Trying to set non-bool option " << name
|
---|
576 | << " to boolean value.\n" << flush;
|
---|
577 | exit(1);
|
---|
578 | }
|
---|
579 | }
|
---|
580 |
|
---|
581 | void
|
---|
582 | Environment::SetVector(const char *name,
|
---|
583 | const Vector3 &v)
|
---|
584 | {
|
---|
585 | int i = FindOption(name);
|
---|
586 | if (i<0)
|
---|
587 | return;
|
---|
588 |
|
---|
589 | if (options[i].type == optVector) {
|
---|
590 | delete options[i].value;
|
---|
591 | options[i].value = new char[128];
|
---|
592 | sprintf(options[i].value, "%.15e,%.15e,%.15e", v.x, v.y, v.z);
|
---|
593 | }
|
---|
594 | else {
|
---|
595 | Debug << "Internal error: Trying to set non-vector option " << name
|
---|
596 | << " to vector value.\n" << flush;
|
---|
597 | exit(1);
|
---|
598 | }
|
---|
599 | }
|
---|
600 |
|
---|
601 | void
|
---|
602 | Environment::SetString(const char *name, const char *value)
|
---|
603 | {
|
---|
604 | int i = FindOption(name);
|
---|
605 | if (i<0)
|
---|
606 | return;
|
---|
607 |
|
---|
608 | if (options[i].type == optString) {
|
---|
609 | delete options[i].value;
|
---|
610 | options[i].value = strdup(value);
|
---|
611 | }
|
---|
612 | else {
|
---|
613 | Debug << "Internal error: Trying to set non-string option " << name
|
---|
614 | << " to string value.\n" << flush;
|
---|
615 | exit(1);
|
---|
616 | }
|
---|
617 | }
|
---|
618 |
|
---|
619 | void
|
---|
620 | Environment::ParseCmdline(const int argc,
|
---|
621 | char **argv,
|
---|
622 | const int index)
|
---|
623 | {
|
---|
624 | int curIndex = -1;
|
---|
625 |
|
---|
626 | for (int i = 1; i < argc; i++) {
|
---|
627 | // if this parameter is non-optional, skip it and increment the counter
|
---|
628 | if (argv[i][0] != '-') {
|
---|
629 | curIndex++;
|
---|
630 | continue;
|
---|
631 | }
|
---|
632 | // make sure to skip all non-optional parameters
|
---|
633 | char *t = strchr(optionalParams, argv[i][1]);
|
---|
634 | if (t != NULL)
|
---|
635 | continue;
|
---|
636 |
|
---|
637 | // if we are in the scope of the current parameter, parse it
|
---|
638 | if (curIndex == -1 || curIndex == index) {
|
---|
639 | if (argv[i][1] == 'D') {
|
---|
640 | // it's a full name definition
|
---|
641 | bool found = false;
|
---|
642 | int j;
|
---|
643 |
|
---|
644 | char *t = strchr(argv[i] + 2, '=');
|
---|
645 | if (t == NULL) {
|
---|
646 | Debug << "Error: Missing '=' in option. "
|
---|
647 | << "Syntax is -D<name>=<value>.\n" << flush;
|
---|
648 | exit(1);
|
---|
649 | }
|
---|
650 | for (j = 0; j < numOptions; j++)
|
---|
651 | if (!strncmp(options[j].name, argv[i] + 2, t - argv[i] - 2) &&
|
---|
652 | (unsigned)(t - argv[i] - 2) == strlen(options[j].name)) {
|
---|
653 | found = true;
|
---|
654 | break;
|
---|
655 | }
|
---|
656 | if (!found) {
|
---|
657 | Debug << "Warning: Unregistered option " << argv[i] << ".\n" << flush;
|
---|
658 | // exit(1);
|
---|
659 | }
|
---|
660 | if (found) {
|
---|
661 | if (!CheckType(t + 1, options[j].type)) {
|
---|
662 | Debug << "Error: invalid type of value " << t + 1 << " in option "
|
---|
663 | << options[j].name << ".\n";
|
---|
664 | exit(1);
|
---|
665 | }
|
---|
666 | if (options[j].value != NULL)
|
---|
667 | delete options[j].value;
|
---|
668 | options[j].value = strdup(t + 1);
|
---|
669 | }
|
---|
670 | }
|
---|
671 | else {
|
---|
672 | // it's an abbreviation
|
---|
673 | bool found = false;
|
---|
674 | int j;
|
---|
675 |
|
---|
676 | for (j = 0; j < numOptions; j++)
|
---|
677 | if (options[j].abbrev != NULL &&
|
---|
678 | !strncmp(options[j].abbrev, argv[i] + 1, strlen(options[j].abbrev))) {
|
---|
679 | found = true;
|
---|
680 | break;
|
---|
681 | }
|
---|
682 | if (!found) {
|
---|
683 | Debug << "Warning: Unregistered option " << argv[i] << ".\n" << flush;
|
---|
684 | // exit(1);
|
---|
685 | }
|
---|
686 | if (found) {
|
---|
687 | if (!CheckType(argv[i] + 1 + strlen(options[j].abbrev), options[j].type)) {
|
---|
688 | Debug << "Error: invalid type of value "
|
---|
689 | << argv[i] + 1 + strlen(options[j].abbrev) << "in option "
|
---|
690 | << options[j].name << ".\n";
|
---|
691 | exit(1);
|
---|
692 | }
|
---|
693 | if (options[j].value != NULL)
|
---|
694 | delete options[j].value;
|
---|
695 | options[j].value = strdup(argv[i] + 1 + strlen(options[j].abbrev));
|
---|
696 | }
|
---|
697 | }
|
---|
698 | }
|
---|
699 | }
|
---|
700 | #ifdef _DEBUG_PARAMS
|
---|
701 | // write out the options table
|
---|
702 | cerr << "Options table for " << numOptions << " options:\n";
|
---|
703 | for (int j = 0; j < numOptions; j++) {
|
---|
704 | cerr << options[j];
|
---|
705 | cerr << "\n";
|
---|
706 | }
|
---|
707 | cerr << "Options done.\n" << flush;
|
---|
708 | #endif // _DEBUG_PARAMS
|
---|
709 | }
|
---|
710 |
|
---|
711 |
|
---|
712 | char *
|
---|
713 | Environment::ParseString(char *buffer, char *string) const
|
---|
714 | {
|
---|
715 | char *s = buffer;
|
---|
716 | char *t = string + strlen(string);
|
---|
717 |
|
---|
718 | // skip leading whitespaces
|
---|
719 | while (*s == ' ' || *s == '\t')
|
---|
720 | s++;
|
---|
721 | if (*s == '\0')
|
---|
722 | return NULL;
|
---|
723 | while ((*s >= 'a' && *s <= 'z') ||
|
---|
724 | (*s >= 'A' && *s <= 'Z') ||
|
---|
725 | (*s >= '0' && *s <= '9') ||
|
---|
726 | *s == '_')
|
---|
727 | *t++ = *s++;
|
---|
728 | *t = '\0';
|
---|
729 | // skip trailing whitespaces
|
---|
730 | while (*s == ' ' || *s == '\t')
|
---|
731 | s++;
|
---|
732 | return s;
|
---|
733 | }
|
---|
734 |
|
---|
735 | const char code[] = "JIDHipewhfdhyd74387hHO&{WK:DOKQEIDKJPQ*H#@USX:#FWCQ*EJMQAHPQP(@G#RD";
|
---|
736 |
|
---|
737 | void
|
---|
738 | Environment::DecodeString(char *buff, int max)
|
---|
739 | {
|
---|
740 | buff[max] = 0;
|
---|
741 | char *p = buff;
|
---|
742 | const char *cp = code;
|
---|
743 | for (; *p; p++) {
|
---|
744 | if (*p != '\n')
|
---|
745 | *p = *p ^ *cp;
|
---|
746 | ++cp;
|
---|
747 | if (*cp == 0)
|
---|
748 | cp = code;
|
---|
749 | }
|
---|
750 | }
|
---|
751 |
|
---|
752 | void
|
---|
753 | Environment::CodeString(char *buff, int max)
|
---|
754 | {
|
---|
755 | buff[max] = 0;
|
---|
756 | char *p = buff;
|
---|
757 | const char *cp = code;
|
---|
758 | for (; *p; p++) {
|
---|
759 | if (*p != '\n')
|
---|
760 | *p = *p ^ *cp;
|
---|
761 | ++cp;
|
---|
762 | if (*cp == 0)
|
---|
763 | cp = code;
|
---|
764 | }
|
---|
765 | }
|
---|
766 |
|
---|
767 | void
|
---|
768 | Environment::SaveCodedFile(char *filenameText,
|
---|
769 | char *filenameCoded)
|
---|
770 | {
|
---|
771 | ifstream envStream(filenameText);
|
---|
772 |
|
---|
773 | // some error had occured
|
---|
774 | if (envStream.fail()) {
|
---|
775 | cerr << "Error: Can't open file " << filenameText << " for reading (err. "
|
---|
776 | << envStream.rdstate() << ").\n";
|
---|
777 | return;
|
---|
778 | }
|
---|
779 | char buff[256];
|
---|
780 | envStream.getline(buff, 255);
|
---|
781 | buff[8] = 0;
|
---|
782 | if (strcmp(buff, "CGX_CF10") == 0)
|
---|
783 | return;
|
---|
784 |
|
---|
785 | ofstream cStream(filenameCoded);
|
---|
786 | cStream<<"CGX_CF10";
|
---|
787 |
|
---|
788 | // main loop
|
---|
789 | for (;;) {
|
---|
790 | // read in one line
|
---|
791 | envStream.getline(buff, 255);
|
---|
792 | if (!envStream)
|
---|
793 | break;
|
---|
794 | CodeString(buff, 255);
|
---|
795 | cStream<<buff;
|
---|
796 | }
|
---|
797 |
|
---|
798 | }
|
---|
799 |
|
---|
800 | bool
|
---|
801 | Environment::ReadEnvFile(const char *envFilename)
|
---|
802 | {
|
---|
803 | char buff[MaxStringLength], name[MaxStringLength];
|
---|
804 | char *s, *t;
|
---|
805 | int i, line = 0;
|
---|
806 | bool found;
|
---|
807 | igzstream envStream(envFilename);
|
---|
808 |
|
---|
809 | // some error had occured
|
---|
810 | if (envStream.fail()) {
|
---|
811 | cerr << "Error: Can't open file " << envFilename << " for reading (err. "
|
---|
812 | << envStream.rdstate() << ").\n";
|
---|
813 | return false;
|
---|
814 | }
|
---|
815 |
|
---|
816 | name[0] = '\0';
|
---|
817 |
|
---|
818 | // bool coded;
|
---|
819 | // envStream.getline(buff, 255);
|
---|
820 | // buff[8] = 0;
|
---|
821 | // if (strcmp(buff, "CGX_CF10") == 0)
|
---|
822 | // coded = true;
|
---|
823 | // else {
|
---|
824 | // coded = false;
|
---|
825 | // envStream.Rewind();
|
---|
826 | // }
|
---|
827 |
|
---|
828 | // main loop
|
---|
829 | for (;;) {
|
---|
830 | // read in one line
|
---|
831 | envStream.getline(buff, 255);
|
---|
832 |
|
---|
833 | if (!envStream)
|
---|
834 | break;
|
---|
835 |
|
---|
836 | // if (coded)
|
---|
837 | // DecodeString(buff, 255);
|
---|
838 |
|
---|
839 | line++;
|
---|
840 | // get rid of comments
|
---|
841 | s = strchr(buff, '#');
|
---|
842 | if (s != NULL)
|
---|
843 | *s = '\0';
|
---|
844 |
|
---|
845 | // get one identifier
|
---|
846 | s = ParseString(buff, name);
|
---|
847 | // parse line
|
---|
848 | while (s != NULL) {
|
---|
849 | // it's a group name - make the full name
|
---|
850 | if (*s == '{') {
|
---|
851 | strcat(name, ".");
|
---|
852 | s++;
|
---|
853 | s = ParseString(s, name);
|
---|
854 | continue;
|
---|
855 | }
|
---|
856 | // end of group
|
---|
857 | if (*s == '}') {
|
---|
858 | if (strlen(name) == 0) {
|
---|
859 | cerr << "Error: unpaired } in " << envFilename << " (line "
|
---|
860 | << line << ").\n";
|
---|
861 | envStream.close();
|
---|
862 | return false;
|
---|
863 | }
|
---|
864 | name[strlen(name) - 1] = '\0';
|
---|
865 | t = strrchr(name, '.');
|
---|
866 | if (t == NULL)
|
---|
867 | name[0] = '\0';
|
---|
868 | else
|
---|
869 | *(t + 1) = '\0';
|
---|
870 | s++;
|
---|
871 | s = ParseString(s, name);
|
---|
872 | continue;
|
---|
873 | }
|
---|
874 | // find variable name in the table
|
---|
875 | found = false;
|
---|
876 | for (i = 0; i < numOptions; i++)
|
---|
877 | if (!strcmp(name, options[i].name)) {
|
---|
878 | found = true;
|
---|
879 | break;
|
---|
880 | }
|
---|
881 | if (!found) {
|
---|
882 | cerr << "Warning: unknown option " << name << " in environment file "
|
---|
883 | << envFilename << " (line " << line << ").\n";
|
---|
884 | } else
|
---|
885 | switch (options[i].type) {
|
---|
886 | case optInt: {
|
---|
887 | strtol(s, &t, 10);
|
---|
888 | if (t == s || (*t != ' ' && *t != '\t' &&
|
---|
889 | *t != '\0' && *t != '}')) {
|
---|
890 | cerr << "Error: Mismatch in int variable " << name << " in "
|
---|
891 | << "environment file " << envFilename << " (line "
|
---|
892 | << line << ").\n";
|
---|
893 | envStream.close();
|
---|
894 | return false;
|
---|
895 | }
|
---|
896 | if (options[i].value != NULL)
|
---|
897 | delete options[i].value;
|
---|
898 | options[i].value = new char[t - s + 1];
|
---|
899 | strncpy(options[i].value, s, t - s);
|
---|
900 | options[i].value[t - s] = '\0';
|
---|
901 | s = t;
|
---|
902 | break;
|
---|
903 | }
|
---|
904 | case optFloat: {
|
---|
905 | strtod(s, &t);
|
---|
906 | if (t == s || (*t != ' ' && *t != '\t' &&
|
---|
907 | *t != '\0' && *t != '}')) {
|
---|
908 | cerr << "Error: Mismatch in Real variable " << name << " in "
|
---|
909 | << "environment file " << envFilename << " (line "
|
---|
910 | << line << ").\n";
|
---|
911 | envStream.close();
|
---|
912 | return false;
|
---|
913 | }
|
---|
914 | if (options[i].value != NULL)
|
---|
915 | delete options[i].value;
|
---|
916 | options[i].value = new char[t - s + 1];
|
---|
917 | strncpy(options[i].value, s, t - s);
|
---|
918 | options[i].value[t - s] = '\0';
|
---|
919 | s = t;
|
---|
920 | break;
|
---|
921 | }
|
---|
922 | case optBool: {
|
---|
923 | t = s;
|
---|
924 | while ((*t >= 'a' && *t <= 'z') ||
|
---|
925 | (*t >= 'A' && *t <= 'Z') ||
|
---|
926 | *t == '+' || *t == '-')
|
---|
927 | t++;
|
---|
928 | if (((!strncasecmp(s, "true", t - s) && t - s == 4) ||
|
---|
929 | (!strncasecmp(s, "false", t - s) && t - s == 5) ||
|
---|
930 | (!strncasecmp(s, "YES", t -s) && t - s == 3) ||
|
---|
931 | (!strncasecmp(s, "NO", t - s) && t - s == 2) ||
|
---|
932 | (!strncasecmp(s, "ON", t - s) && t - s == 2) ||
|
---|
933 | (!strncasecmp(s, "OFF", t - s) && t - s == 3) ||
|
---|
934 | (t - s == 1 && (*s == '+' || *s == '-'))) &&
|
---|
935 | (*t == ' ' || *t == '\t' || *t == '\0' || *t == '}')) {
|
---|
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 | }
|
---|
943 | else {
|
---|
944 | cerr << "Error: Mismatch in bool variable " << name << " in "
|
---|
945 | << "environment file " << envFilename << " (line "
|
---|
946 | << line << ").\n";
|
---|
947 | envStream.close();
|
---|
948 | return false;
|
---|
949 | }
|
---|
950 | break;
|
---|
951 | }
|
---|
952 | case optVector:{
|
---|
953 | strtod(s, &t);
|
---|
954 | if (*t == ' ' || *t == '\t') {
|
---|
955 | while (*t == ' ' || *t == '\t')
|
---|
956 | t++;
|
---|
957 | if (*t != ',')
|
---|
958 | t--;
|
---|
959 | }
|
---|
960 | if (t == s || (*t != ' ' && *t != '\t' && *t != ',')) {
|
---|
961 | cerr << "Error: Mismatch in vector variable " << name << " in "
|
---|
962 | << "environment file " << envFilename << " (line "
|
---|
963 | << line << ").\n";
|
---|
964 | envStream.close();
|
---|
965 | return false;
|
---|
966 | }
|
---|
967 | char *u;
|
---|
968 | strtod(t, &u);
|
---|
969 | t = u;
|
---|
970 | if (*t == ' ' || *t == '\t') {
|
---|
971 | while (*t == ' ' || *t == '\t')
|
---|
972 | t++;
|
---|
973 | if (*t != ',')
|
---|
974 | t--;
|
---|
975 | }
|
---|
976 | if (t == s || (*t != ' ' && *t != '\t' && *t != ',')) {
|
---|
977 | cerr << "Error: Mismatch in vector variable " << name << " in "
|
---|
978 | << "environment file " << envFilename << " (line "
|
---|
979 | << line << ").\n";
|
---|
980 | envStream.close();
|
---|
981 | return false;
|
---|
982 | }
|
---|
983 | strtod(t, &u);
|
---|
984 | t = u;
|
---|
985 | if (t == s || (*t != ' ' && *t != '\t' &&
|
---|
986 | *t != '\0' && *t != '}')) {
|
---|
987 | cerr << "Error: Mismatch in vector variable " << name << " in "
|
---|
988 | << "environment file " << envFilename << " (line "
|
---|
989 | << line << ").\n";
|
---|
990 | envStream.close();
|
---|
991 | return false;
|
---|
992 | }
|
---|
993 | if (options[i].value != NULL)
|
---|
994 | delete options[i].value;
|
---|
995 | options[i].value = new char[t - s + 1];
|
---|
996 | strncpy(options[i].value, s, t - s);
|
---|
997 | options[i].value[t - s] = '\0';
|
---|
998 | s = t;
|
---|
999 | break;
|
---|
1000 | }
|
---|
1001 | case optString: {
|
---|
1002 | if (options[i].value != NULL)
|
---|
1003 | delete options[i].value;
|
---|
1004 | options[i].value = new char[strlen(s) + 1];
|
---|
1005 | strcpy(options[i].value, s);
|
---|
1006 | s += strlen(s);
|
---|
1007 | break;
|
---|
1008 | }
|
---|
1009 | default: {
|
---|
1010 | Debug << "Internal error: Unknown type of option.\n" << flush;
|
---|
1011 | exit(1);
|
---|
1012 | }
|
---|
1013 | }
|
---|
1014 | // prepare the variable name for next pass
|
---|
1015 | t = strrchr(name, '.');
|
---|
1016 | if (t == NULL)
|
---|
1017 | name[0] = '\0';
|
---|
1018 | else
|
---|
1019 | *(t + 1) = '\0';
|
---|
1020 | // get next identifier
|
---|
1021 | s = ParseString(s, name);
|
---|
1022 | }
|
---|
1023 | }
|
---|
1024 | envStream.close();
|
---|
1025 | return true;
|
---|
1026 | }
|
---|
1027 |
|
---|
1028 | void
|
---|
1029 | Environment::PrintUsage(ostream &s) const
|
---|
1030 | {
|
---|
1031 | // Print out all environment variable names
|
---|
1032 | s << "Registered options:\n";
|
---|
1033 | for (int j = 0; j < numOptions; j++)
|
---|
1034 | s << options[j] << "\n";
|
---|
1035 | s << flush;
|
---|
1036 | }
|
---|
1037 |
|
---|
1038 |
|
---|
1039 | Environment::Environment()
|
---|
1040 | {
|
---|
1041 | optionalParams = NULL;
|
---|
1042 | paramRows = 0;
|
---|
1043 | numParams = 0;
|
---|
1044 | params = NULL;
|
---|
1045 | maxOptions = 500;
|
---|
1046 |
|
---|
1047 |
|
---|
1048 | // this is maximal nuber of options.
|
---|
1049 | numOptions = 0;
|
---|
1050 |
|
---|
1051 | options = new COption[maxOptions];
|
---|
1052 |
|
---|
1053 | if (options == NULL ) {
|
---|
1054 | Debug << "Error: Memory allocation failed.\n";
|
---|
1055 | exit(1);
|
---|
1056 | }
|
---|
1057 |
|
---|
1058 | // register all basic options
|
---|
1059 |
|
---|
1060 | RegisterOption("Limits.threshold", optFloat, NULL, "0.01");
|
---|
1061 | RegisterOption("Limits.small", optFloat, NULL, "1e-6");
|
---|
1062 | RegisterOption("Limits.infinity", optFloat, NULL, "1e6");
|
---|
1063 |
|
---|
1064 |
|
---|
1065 | RegisterOption("Scene.filename",
|
---|
1066 | optString,
|
---|
1067 | "scene_filename=",
|
---|
1068 | "atlanta2.x3d");
|
---|
1069 |
|
---|
1070 | RegisterOption("Unigraphics.meshGrouping",
|
---|
1071 | optInt,
|
---|
1072 | "unigraphics_mesh_grouping=",
|
---|
1073 | "0");
|
---|
1074 |
|
---|
1075 |
|
---|
1076 | RegisterOption("KdTree.Termination.minCost",
|
---|
1077 | optInt,
|
---|
1078 | "kd_term_min_cost=",
|
---|
1079 | "10");
|
---|
1080 |
|
---|
1081 | RegisterOption("KdTree.Termination.maxDepth",
|
---|
1082 | optInt,
|
---|
1083 | "kd_term_max_depth=",
|
---|
1084 | "20");
|
---|
1085 |
|
---|
1086 | RegisterOption("KdTree.Termination.maxCostRatio",
|
---|
1087 | optFloat,
|
---|
1088 | "kd_term_max_cost_ratio=",
|
---|
1089 | "1.5");
|
---|
1090 |
|
---|
1091 | RegisterOption("KdTree.Termination.ct_div_ci",
|
---|
1092 | optFloat,
|
---|
1093 | "kd_term_ct_div_ci=",
|
---|
1094 | "1.0");
|
---|
1095 |
|
---|
1096 | RegisterOption("KdTree.splitMethod",
|
---|
1097 | optString,
|
---|
1098 | "kd_split_method=",
|
---|
1099 | "spatialMedian");
|
---|
1100 |
|
---|
1101 | RegisterOption("KdTree.splitBorder",
|
---|
1102 | optFloat,
|
---|
1103 | "kd_split_border=",
|
---|
1104 | "0.1");
|
---|
1105 |
|
---|
1106 | RegisterOption("KdTree.sahUseFaces",
|
---|
1107 | optBool,
|
---|
1108 | "kd_sah_use_faces=",
|
---|
1109 | "true");
|
---|
1110 |
|
---|
1111 |
|
---|
1112 | RegisterOption("MeshKdTree.Termination.minCost",
|
---|
1113 | optInt,
|
---|
1114 | "kd_term_min_cost=",
|
---|
1115 | "10");
|
---|
1116 |
|
---|
1117 | RegisterOption("MeshKdTree.Termination.maxDepth",
|
---|
1118 | optInt,
|
---|
1119 | "kd_term_max_depth=",
|
---|
1120 | "20");
|
---|
1121 |
|
---|
1122 | RegisterOption("MeshKdTree.Termination.maxCostRatio",
|
---|
1123 | optFloat,
|
---|
1124 | "kd_term_max_cost_ratio=",
|
---|
1125 | "1.5");
|
---|
1126 |
|
---|
1127 | RegisterOption("MeshKdTree.Termination.ct_div_ci",
|
---|
1128 | optFloat,
|
---|
1129 | "kd_term_ct_div_ci=",
|
---|
1130 | "1.0");
|
---|
1131 |
|
---|
1132 | RegisterOption("MeshKdTree.splitMethod",
|
---|
1133 | optString,
|
---|
1134 | "kd_split_method=",
|
---|
1135 | "spatialMedian");
|
---|
1136 |
|
---|
1137 | RegisterOption("MeshKdTree.splitBorder",
|
---|
1138 | optFloat,
|
---|
1139 | "kd_split_border=",
|
---|
1140 | "0.1");
|
---|
1141 |
|
---|
1142 | RegisterOption("SamplingPreprocessor.totalSamples",
|
---|
1143 | optInt,
|
---|
1144 | "total_samples=",
|
---|
1145 | "1000000");
|
---|
1146 |
|
---|
1147 | RegisterOption("SamplingPreprocessor.samplesPerPass",
|
---|
1148 | optInt,
|
---|
1149 | "samples_per_pass=",
|
---|
1150 | "10");
|
---|
1151 |
|
---|
1152 | RegisterOption("VssPreprocessor.initialSamples",
|
---|
1153 | optInt,
|
---|
1154 | "initial_samples=",
|
---|
1155 | "100000");
|
---|
1156 |
|
---|
1157 | RegisterOption("VssPreprocessor.testBeamSampling", optBool, "beam_sampling", "false");
|
---|
1158 |
|
---|
1159 | RegisterOption("VssPreprocessor.vssSamples",
|
---|
1160 | optInt,
|
---|
1161 | "vss_samples=",
|
---|
1162 | "1000000");
|
---|
1163 |
|
---|
1164 | RegisterOption("VssPreprocessor.vssSamplesPerPass",
|
---|
1165 | optInt,
|
---|
1166 | "vss_samples_per_pass=",
|
---|
1167 | "1000");
|
---|
1168 |
|
---|
1169 | RegisterOption("VssPreprocessor.samplesPerPass",
|
---|
1170 | optInt,
|
---|
1171 | "samples_per_pass=",
|
---|
1172 | "100000");
|
---|
1173 |
|
---|
1174 | RegisterOption("VssPreprocessor.useImportanceSampling",
|
---|
1175 | optBool,
|
---|
1176 | "vss_use_importance=",
|
---|
1177 | "true");
|
---|
1178 |
|
---|
1179 | RegisterOption("VssPreprocessor.loadInitialSamples",
|
---|
1180 | optBool,
|
---|
1181 | "-vss_load_loadInitialSamples=",
|
---|
1182 | "false");
|
---|
1183 |
|
---|
1184 | RegisterOption("VssPreprocessor.storeInitialSamples",
|
---|
1185 | optBool,
|
---|
1186 | "-vss_store_storedInitialSamples=",
|
---|
1187 | "false");
|
---|
1188 |
|
---|
1189 |
|
---|
1190 | RegisterOption("VssPreprocessor.useViewSpaceBox",
|
---|
1191 | optBool,
|
---|
1192 | "-vss_use_viewspace_box=",
|
---|
1193 | "false");
|
---|
1194 |
|
---|
1195 |
|
---|
1196 | /************************************************************************************/
|
---|
1197 | /* View cells related options */
|
---|
1198 | /************************************************************************************/
|
---|
1199 |
|
---|
1200 |
|
---|
1201 | RegisterOption("ViewCells.type",
|
---|
1202 | optString,
|
---|
1203 | "view_cells_type=",
|
---|
1204 | "vspBspTree");
|
---|
1205 |
|
---|
1206 | RegisterOption("ViewCells.samplingType",
|
---|
1207 | optString,
|
---|
1208 | "view_cells_sampling_type=",
|
---|
1209 | "box");
|
---|
1210 |
|
---|
1211 | RegisterOption("ViewCells.mergeStats",
|
---|
1212 | optString,
|
---|
1213 | "view_cells_merge_stats=",
|
---|
1214 | "mergeStats.log");
|
---|
1215 |
|
---|
1216 | RegisterOption("ViewCells.Evaluation.statsPrefix",
|
---|
1217 | optString,
|
---|
1218 | "view_cells_evaluation_stats_prefix=",
|
---|
1219 | "viewCells");
|
---|
1220 |
|
---|
1221 | RegisterOption("ViewCells.active",
|
---|
1222 | optInt,
|
---|
1223 | "view_cells_active=",
|
---|
1224 | "1000");
|
---|
1225 |
|
---|
1226 | RegisterOption("ViewCells.Construction.samples",
|
---|
1227 | optInt,
|
---|
1228 | "view_cells_construction_samples=",
|
---|
1229 | "5000000");
|
---|
1230 |
|
---|
1231 | RegisterOption("ViewCells.Construction.samplesPerPass",
|
---|
1232 | optInt,
|
---|
1233 | "view_cells_construction_samples_per_pass=",
|
---|
1234 | "500000");
|
---|
1235 |
|
---|
1236 | RegisterOption("ViewCells.PostProcess.samples",
|
---|
1237 | optInt,
|
---|
1238 | "view_cells_postprocess_samples=",
|
---|
1239 | "200000");
|
---|
1240 |
|
---|
1241 | RegisterOption("ViewCells.Visualization.samples",
|
---|
1242 | optInt,
|
---|
1243 | "view_cells_visualization_samples=",
|
---|
1244 | "20000");
|
---|
1245 |
|
---|
1246 | RegisterOption("ViewCells.loadFromFile",
|
---|
1247 | optBool,
|
---|
1248 | "view_cells_load_from_file=",
|
---|
1249 | "false");
|
---|
1250 |
|
---|
1251 | RegisterOption("ViewCells.PostProcess.refine",
|
---|
1252 | optBool,
|
---|
1253 | "view_cells_refine=",
|
---|
1254 | "false");
|
---|
1255 |
|
---|
1256 | RegisterOption("ViewCells.PostProcess.compress",
|
---|
1257 | optBool,
|
---|
1258 | "view_cells_post_process_compress=",
|
---|
1259 | "false");
|
---|
1260 |
|
---|
1261 | RegisterOption("ViewCells.Evaluation.samples",
|
---|
1262 | optInt,
|
---|
1263 | "view_cells_evaluation_samples=",
|
---|
1264 | "8000000");
|
---|
1265 |
|
---|
1266 | RegisterOption("ViewCells.Evaluation.samplesPerPass",
|
---|
1267 | optInt,
|
---|
1268 | "view_cells_evaluation_samples_per_pass=",
|
---|
1269 | "300000");
|
---|
1270 |
|
---|
1271 | RegisterOption("ViewCells.exportToFile",
|
---|
1272 | optBool,
|
---|
1273 | "view_cells_export_to_file",
|
---|
1274 | "false");
|
---|
1275 |
|
---|
1276 | RegisterOption("ViewCells.evaluateViewCells",
|
---|
1277 | optBool,
|
---|
1278 | "view_cells_evaluate_view_cells=",
|
---|
1279 | "false");
|
---|
1280 |
|
---|
1281 | RegisterOption("ViewCells.maxViewCells",
|
---|
1282 | optInt,
|
---|
1283 | "view_cells_max_view_cells=",
|
---|
1284 | "0");
|
---|
1285 |
|
---|
1286 | RegisterOption("ViewCells.maxPvsRatio",
|
---|
1287 | optFloat,
|
---|
1288 | "view_cells_max_pvs_ratio=",
|
---|
1289 | "0.1");
|
---|
1290 |
|
---|
1291 | RegisterOption("ViewCells.filename",
|
---|
1292 | optString,
|
---|
1293 | "view_cells_filename=",
|
---|
1294 | "atlanta_viewcells_large.x3d");
|
---|
1295 |
|
---|
1296 | RegisterOption("ViewCells.height",
|
---|
1297 | optFloat,
|
---|
1298 | "view_cells_height=",
|
---|
1299 | "5.0");
|
---|
1300 |
|
---|
1301 | RegisterOption("ViewCells.Visualization.colorCode",
|
---|
1302 | optString,
|
---|
1303 | "view_cells_visualization_color_code",
|
---|
1304 | "PVS");
|
---|
1305 |
|
---|
1306 | RegisterOption("ViewCells.Visualization.clipPlanePos",
|
---|
1307 | optFloat,
|
---|
1308 | "view_cells_visualization_clip_plane_pos",
|
---|
1309 | "0.35");
|
---|
1310 |
|
---|
1311 | RegisterOption("ViewCells.Visualization.exportGeometry",
|
---|
1312 | optBool,
|
---|
1313 | "view_cells_visualization_export_geometry",
|
---|
1314 | "false");
|
---|
1315 |
|
---|
1316 | RegisterOption("ViewCells.Visualization.exportRays",
|
---|
1317 | optBool,
|
---|
1318 | "view_cells_visualization_export_rays",
|
---|
1319 | "false");
|
---|
1320 |
|
---|
1321 | RegisterOption("ViewCells.pruneEmptyViewCells",
|
---|
1322 | optBool,
|
---|
1323 | "view_cells_prune_empty_view_cells",
|
---|
1324 | "false");
|
---|
1325 |
|
---|
1326 | RegisterOption("ViewCells.processOnlyValidViewCells",
|
---|
1327 | optBool,
|
---|
1328 | "view_cells_process_only_valid_view_cells",
|
---|
1329 | "false");
|
---|
1330 |
|
---|
1331 |
|
---|
1332 | RegisterOption("ViewCells.PostProcess.maxCostRatio",
|
---|
1333 | optFloat,
|
---|
1334 | "view_cells_post_process_max_cost_ratio=",
|
---|
1335 | "0.9");
|
---|
1336 |
|
---|
1337 | RegisterOption("ViewCells.PostProcess.renderCostWeight",
|
---|
1338 | optFloat,
|
---|
1339 | "view_cells_post_process_render_cost_weight",
|
---|
1340 | "0.5");
|
---|
1341 |
|
---|
1342 | RegisterOption("ViewCells.PostProcess.avgCostMaxDeviation",
|
---|
1343 | optFloat,
|
---|
1344 | "vsp_bsp_avgcost_max_deviations",
|
---|
1345 | "0.5");
|
---|
1346 |
|
---|
1347 | RegisterOption("ViewCells.PostProcess.maxMergesPerPass",
|
---|
1348 | optInt,
|
---|
1349 | "view_cells_post_process_max_merges_per_pass=",
|
---|
1350 | "500");
|
---|
1351 |
|
---|
1352 | RegisterOption("ViewCells.PostProcess.minViewCells",
|
---|
1353 | optInt,
|
---|
1354 | "view_cells_post_process_min_view_cells=",
|
---|
1355 | "1000");
|
---|
1356 |
|
---|
1357 | RegisterOption("ViewCells.PostProcess.useRaysForMerge",
|
---|
1358 | optBool,
|
---|
1359 | "view_cells_post_process_use_rays_for_merge=",
|
---|
1360 | "false");
|
---|
1361 |
|
---|
1362 | RegisterOption("ViewCells.PostProcess.merge",
|
---|
1363 | optBool,
|
---|
1364 | "view_cells_post_process_merge=",
|
---|
1365 | "true");
|
---|
1366 |
|
---|
1367 | RegisterOption("ViewCells.Visualization.exportMergedViewCells",
|
---|
1368 | optBool,
|
---|
1369 | "view_cells_viz_export_merged_viewcells=",
|
---|
1370 | "false");
|
---|
1371 |
|
---|
1372 | RegisterOption("ViewCells.maxStaticMemory",
|
---|
1373 | optFloat,
|
---|
1374 | "view_cells_max_static_mem=",
|
---|
1375 | "8.0");
|
---|
1376 |
|
---|
1377 | RegisterOption("ViewCells.Visualization.useClipPlane",
|
---|
1378 | optBool,
|
---|
1379 | "view_cells_viz_use_clip_plane=",
|
---|
1380 | "false");
|
---|
1381 |
|
---|
1382 | RegisterOption("ViewCells.showVisualization",
|
---|
1383 | optBool,
|
---|
1384 | "view_cells_show_visualization=",
|
---|
1385 | "false");
|
---|
1386 |
|
---|
1387 | RegisterOption("ViewCells.Visualization.clipPlaneAxis",
|
---|
1388 | optInt,
|
---|
1389 | "view_cells_viz_clip_plane_axis=",
|
---|
1390 | "0");
|
---|
1391 |
|
---|
1392 |
|
---|
1393 | /************************************************************************************/
|
---|
1394 | /* Render simulation related options */
|
---|
1395 | /************************************************************************************/
|
---|
1396 |
|
---|
1397 |
|
---|
1398 | RegisterOption("Simulation.objRenderCost",
|
---|
1399 | optFloat,
|
---|
1400 | "simulation_obj_render_cost",
|
---|
1401 | "1.0");
|
---|
1402 |
|
---|
1403 | RegisterOption("Simulation.vcOverhead",
|
---|
1404 | optFloat,
|
---|
1405 | "simulation_vc_overhead",
|
---|
1406 | "0.05");
|
---|
1407 |
|
---|
1408 | RegisterOption("Simulation.moveSpeed",
|
---|
1409 | optFloat,
|
---|
1410 | "simulation_moveSpeed",
|
---|
1411 | "1.0");
|
---|
1412 |
|
---|
1413 |
|
---|
1414 |
|
---|
1415 |
|
---|
1416 | /************************************************************************************/
|
---|
1417 | /* Bsp tree related options */
|
---|
1418 | /************************************************************************************/
|
---|
1419 |
|
---|
1420 |
|
---|
1421 | RegisterOption("BspTree.Construction.input",
|
---|
1422 | optString,
|
---|
1423 | "bsp_construction_input=",
|
---|
1424 | "fromViewCells");
|
---|
1425 |
|
---|
1426 | RegisterOption("BspTree.subdivisionStats",
|
---|
1427 | optString,
|
---|
1428 | "bsp_subdivision_stats=",
|
---|
1429 | "bspSubdivisionStats.log");
|
---|
1430 |
|
---|
1431 | RegisterOption("BspTree.Construction.samples",
|
---|
1432 | optInt,
|
---|
1433 | "bsp_construction_samples=",
|
---|
1434 | "100000");
|
---|
1435 |
|
---|
1436 | RegisterOption("BspTree.Construction.epsilon",
|
---|
1437 | optFloat,
|
---|
1438 | "bsp_construction_side_tolerance=",
|
---|
1439 | "0.002");
|
---|
1440 |
|
---|
1441 | RegisterOption("BspTree.Termination.minPolygons",
|
---|
1442 | optInt,
|
---|
1443 | "bsp_term_min_polygons=",
|
---|
1444 | "5");
|
---|
1445 |
|
---|
1446 | RegisterOption("BspTree.Termination.minPvs",
|
---|
1447 | optInt,
|
---|
1448 | "bsp_term_min_pvs=",
|
---|
1449 | "20");
|
---|
1450 |
|
---|
1451 | RegisterOption("BspTree.Termination.minProbability",
|
---|
1452 | optFloat,
|
---|
1453 | "bsp_term_min_probability=",
|
---|
1454 | "0.001");
|
---|
1455 |
|
---|
1456 | RegisterOption("BspTree.Termination.maxRayContribution",
|
---|
1457 | optFloat,
|
---|
1458 | "bsp_term_ray_contribution=",
|
---|
1459 | "0.005");
|
---|
1460 |
|
---|
1461 | RegisterOption("BspTree.Termination.minAccRayLenght",
|
---|
1462 | optFloat,
|
---|
1463 | "bsp_term_min_acc_ray_length=",
|
---|
1464 | "50");
|
---|
1465 |
|
---|
1466 | RegisterOption("BspTree.Termination.minRays",
|
---|
1467 | optInt,
|
---|
1468 | "bsp_term_min_rays=",
|
---|
1469 | "-1");
|
---|
1470 |
|
---|
1471 | RegisterOption("BspTree.Termination.ct_div_ci",
|
---|
1472 | optFloat,
|
---|
1473 | "bsp_term_ct_div_ci=",
|
---|
1474 | "0.0");
|
---|
1475 |
|
---|
1476 | RegisterOption("BspTree.Termination.maxDepth",
|
---|
1477 | optInt,
|
---|
1478 | "bsp_term_max_depth=",
|
---|
1479 | "100");
|
---|
1480 |
|
---|
1481 | RegisterOption("BspTree.Termination.maxCostRatio",
|
---|
1482 | optFloat,
|
---|
1483 | "bsp_term_axis_aligned_max_cost_ratio=",
|
---|
1484 | "1.5");
|
---|
1485 |
|
---|
1486 | RegisterOption("BspTree.Termination.AxisAligned.ct_div_ci",
|
---|
1487 | optFloat,
|
---|
1488 | "bsp_term_axis_aligned_ct_div_ci=",
|
---|
1489 | "0.5");
|
---|
1490 |
|
---|
1491 | RegisterOption("BspTree.AxisAligned.splitBorder",
|
---|
1492 | optFloat,
|
---|
1493 | "bsp__axis_aligned_split_border=",
|
---|
1494 | "0.1");
|
---|
1495 |
|
---|
1496 | RegisterOption("BspTree.Termination.AxisAligned.minPolys",
|
---|
1497 | optInt,
|
---|
1498 | "bsp_term_axis_aligned_max_polygons=",
|
---|
1499 | "50");
|
---|
1500 |
|
---|
1501 | RegisterOption("BspTree.Termination.AxisAligned.minObjects",
|
---|
1502 | optInt,
|
---|
1503 | "bsp_term_min_objects=",
|
---|
1504 | "3");
|
---|
1505 |
|
---|
1506 | RegisterOption("BspTree.Termination.AxisAligned.minRays",
|
---|
1507 | optInt,
|
---|
1508 | "bsp_term_axis_aligned_min_rays=",
|
---|
1509 | "-1");
|
---|
1510 |
|
---|
1511 | RegisterOption("BspTree.splitPlaneStrategy",
|
---|
1512 | optString,
|
---|
1513 | "bsp_split_method=",
|
---|
1514 | "leastSplits");
|
---|
1515 |
|
---|
1516 | RegisterOption("BspTree.maxPolyCandidates",
|
---|
1517 | optInt,
|
---|
1518 | "bsp_max_poly_candidates=",
|
---|
1519 | "20");
|
---|
1520 |
|
---|
1521 | RegisterOption("BspTree.maxRayCandidates",
|
---|
1522 | optInt,
|
---|
1523 | "bsp_max_plane_candidates=",
|
---|
1524 | "20");
|
---|
1525 |
|
---|
1526 | RegisterOption("BspTree.maxTests",
|
---|
1527 | optInt,
|
---|
1528 | "bsp_max_tests=",
|
---|
1529 | "5000");
|
---|
1530 |
|
---|
1531 | RegisterOption("BspTree.Termination.maxViewCells",
|
---|
1532 | optInt,
|
---|
1533 | "bsp_max_view_cells=",
|
---|
1534 | "5000");
|
---|
1535 |
|
---|
1536 | RegisterOption("BspTree.Visualization.exportSplits",
|
---|
1537 | optBool,
|
---|
1538 | "bsp_visualization.export_splits",
|
---|
1539 | "false");
|
---|
1540 |
|
---|
1541 | RegisterOption("BspTree.Factor.verticalSplits", optFloat, "bsp_factor_vertical=", "1.0");
|
---|
1542 | RegisterOption("BspTree.Factor.largestPolyArea", optFloat, "bsp_factor_largest_poly=", "1.0");
|
---|
1543 | RegisterOption("BspTree.Factor.blockedRays", optFloat, "bsp_factor_blocked=", "1.0");
|
---|
1544 | RegisterOption("BspTree.Factor.leastSplits", optFloat, "bsp_factor_least_splits=", "1.0");
|
---|
1545 | RegisterOption("BspTree.Factor.balancedPolys", optFloat, "bsp_factor_balanced_polys=", "1.0");
|
---|
1546 | RegisterOption("BspTree.Factor.balancedViewCells", optFloat, "bsp_factor_balanced_view_cells=", "1.0");
|
---|
1547 | RegisterOption("BspTree.Factor.leastRaySplits", optFloat, "bsp_factor_least_ray_splits=", "1.0");
|
---|
1548 | RegisterOption("BspTree.Factor.balancedRays", optFloat, "bsp_factor_balanced_rays=", "1.0");
|
---|
1549 | RegisterOption("BspTree.Factor.pvs", optFloat, "bsp_factor_pvs=", "1.0");
|
---|
1550 |
|
---|
1551 | /************************************************************************************/
|
---|
1552 | /* Preprocessor related options */
|
---|
1553 | /************************************************************************************/
|
---|
1554 |
|
---|
1555 | RegisterOption("Preprocessor.type",
|
---|
1556 | optString,
|
---|
1557 | "preprocessor=",
|
---|
1558 | "sampling");
|
---|
1559 |
|
---|
1560 | RegisterOption("Preprocessor.samplesFilename",
|
---|
1561 | optString,
|
---|
1562 | "-preprocessor_samples_filename=",
|
---|
1563 | "rays.out");
|
---|
1564 |
|
---|
1565 | RegisterOption("Preprocessor.useGlRenderer",
|
---|
1566 | optBool,
|
---|
1567 | "useGlRenderer",
|
---|
1568 | "false");
|
---|
1569 |
|
---|
1570 | RegisterOption("Preprocessor.loadPolygonsAsMeshes",
|
---|
1571 | optBool,
|
---|
1572 | "loadPolygonsAsMeshes=",
|
---|
1573 | "false");
|
---|
1574 |
|
---|
1575 | RegisterOption("Preprocessor.pvsRenderErrorSamples",
|
---|
1576 | optInt,
|
---|
1577 | "pvsRenderErrorSamples=",
|
---|
1578 | "10000");
|
---|
1579 |
|
---|
1580 | RegisterOption("Preprocessor.useGlDebugger",
|
---|
1581 | optBool,
|
---|
1582 | "useGlDebugger",
|
---|
1583 | "false");
|
---|
1584 |
|
---|
1585 | RegisterOption("Preprocessor.detectEmptyViewSpace",
|
---|
1586 | optBool,
|
---|
1587 | "detectEmptyViewSpace",
|
---|
1588 | "false");
|
---|
1589 |
|
---|
1590 | RegisterOption("Preprocessor.quitOnFinish",
|
---|
1591 | optBool,
|
---|
1592 | "quitOnFinish",
|
---|
1593 | "true");
|
---|
1594 |
|
---|
1595 | /**************************************************************************************/
|
---|
1596 | /* View space partition KD tree related options */
|
---|
1597 | /**************************************************************************************/
|
---|
1598 |
|
---|
1599 | RegisterOption("VspKdTree.Construction.samples",
|
---|
1600 | optInt,
|
---|
1601 | "vsp_kd_construction_samples=",
|
---|
1602 | "100000");
|
---|
1603 |
|
---|
1604 | RegisterOption("VspKdTree.Termination.maxDepth",
|
---|
1605 | optInt,
|
---|
1606 | "vsp_term_maxdepth=", "30");
|
---|
1607 |
|
---|
1608 | RegisterOption("VspKdTree.Termination.minPvs",
|
---|
1609 | optInt,
|
---|
1610 | "vsp_minpvs=",
|
---|
1611 | "1");
|
---|
1612 |
|
---|
1613 | RegisterOption("VspKdTree.Termination.minRays",
|
---|
1614 | optInt,
|
---|
1615 | "vsp_term_minrays=",
|
---|
1616 | "10");
|
---|
1617 |
|
---|
1618 | RegisterOption("VspKdTree.Termination.minSize",
|
---|
1619 | optFloat,
|
---|
1620 | "vsp_term_minsize=",
|
---|
1621 | "0.001");
|
---|
1622 |
|
---|
1623 | RegisterOption("VspKdTree.Termination.maxCostRatio",
|
---|
1624 | optFloat,
|
---|
1625 | "vsp_term_maxcost=",
|
---|
1626 | "0.95");
|
---|
1627 |
|
---|
1628 | RegisterOption("VspKdTree.Termination.maxRayContribution",
|
---|
1629 | optFloat,
|
---|
1630 | "vsp_term_max_ray_contrib=",
|
---|
1631 | "0.5");
|
---|
1632 |
|
---|
1633 | RegisterOption("VspKdTree.epsilon",
|
---|
1634 | optFloat,
|
---|
1635 | "kd_eps=",
|
---|
1636 | "1e-6");
|
---|
1637 |
|
---|
1638 | RegisterOption("VspKdTree.ct_div_ci",
|
---|
1639 | optFloat,
|
---|
1640 | "vsp_ctdivci=", "1.0");
|
---|
1641 |
|
---|
1642 | RegisterOption("VspKdTree.splitType",
|
---|
1643 | optString,
|
---|
1644 | "split=",
|
---|
1645 | "queries");
|
---|
1646 |
|
---|
1647 | RegisterOption("VspKdTree.splitAxis",
|
---|
1648 | optString,
|
---|
1649 | "split=",
|
---|
1650 | "drivingAxis");
|
---|
1651 |
|
---|
1652 | RegisterOption("VspKdTree.splitUseOnlyDrivingAxis",
|
---|
1653 | optBool,
|
---|
1654 | "vsp_kd_splitdriving=",
|
---|
1655 | "false");
|
---|
1656 |
|
---|
1657 | RegisterOption("VspKdTree.numberOfEndPointDomains",
|
---|
1658 | optInt,
|
---|
1659 | "endpoints=",
|
---|
1660 | "10000");
|
---|
1661 |
|
---|
1662 | RegisterOption("VspKdTree.maxTotalMemory",
|
---|
1663 | optFloat,
|
---|
1664 | "vsp_max_total_mem=",
|
---|
1665 | "60.0");
|
---|
1666 |
|
---|
1667 | RegisterOption("VspKdTree.maxStaticMemory",
|
---|
1668 | optFloat,
|
---|
1669 | "vsp_max_static_mem=",
|
---|
1670 | "8.0");
|
---|
1671 |
|
---|
1672 | RegisterOption("VspKdTree.queryType",
|
---|
1673 | optString,
|
---|
1674 | "qtype=",
|
---|
1675 | "static");
|
---|
1676 |
|
---|
1677 | RegisterOption("VspKdTree.queryPosWeight",
|
---|
1678 | optFloat,
|
---|
1679 | "vsp_kd_qposweight=",
|
---|
1680 | "0.0");
|
---|
1681 |
|
---|
1682 | RegisterOption("VspKdTree.accessTimeThreshold",
|
---|
1683 | optInt,
|
---|
1684 | "vsp_kd_accesstime=",
|
---|
1685 | "1000");
|
---|
1686 |
|
---|
1687 | RegisterOption("VspKdTree.minCollapseDepth",
|
---|
1688 | optInt,
|
---|
1689 | "vsp_kd_min_colldepth=",
|
---|
1690 | "4");
|
---|
1691 |
|
---|
1692 | RegisterOption("VspKdTree.PostProcess.maxCostRatio",
|
---|
1693 | optFloat,
|
---|
1694 | "vsp_kd_post_process_max_cost_ratio=",
|
---|
1695 | "0.9");
|
---|
1696 |
|
---|
1697 | RegisterOption("VspKdTree.PostProcess.minViewCells",
|
---|
1698 | optInt,
|
---|
1699 | "vsp_kd_term_post_process_min_view_cells=",
|
---|
1700 | "1000");
|
---|
1701 |
|
---|
1702 | RegisterOption("VspKdTree.Termination.maxViewCells",
|
---|
1703 | optInt,
|
---|
1704 | "vsp_kd_term_post_process_min_view_cells=",
|
---|
1705 | "300");
|
---|
1706 |
|
---|
1707 | RegisterOption("VspKdTree.PostProcess.maxPvsSize",
|
---|
1708 | optInt,
|
---|
1709 | "vsp_kd_term_post_process_max_pvs_size=",
|
---|
1710 | "100");
|
---|
1711 |
|
---|
1712 | RegisterOption("VspKdTree.Termination.missTolerance",
|
---|
1713 | optInt,
|
---|
1714 | "-vsp_kd_term_miss_tolerance=",
|
---|
1715 | "4");
|
---|
1716 |
|
---|
1717 | /************************************************************************************/
|
---|
1718 | /* VSS Preprocessor cells related options */
|
---|
1719 | /************************************************************************************/
|
---|
1720 |
|
---|
1721 | RegisterOption("VssTree.maxDepth", optInt, "kd_depth=", "12");
|
---|
1722 | RegisterOption("VssTree.minPvs", optInt, "kd_minpvs=", "1");
|
---|
1723 | RegisterOption("VssTree.minRays", optInt, "kd_minrays=", "10");
|
---|
1724 | RegisterOption("VssTree.maxCostRatio", optFloat, "maxcost=", "0.95");
|
---|
1725 | RegisterOption("VssTree.maxRayContribution", optFloat, "maxraycontrib=", "0.5");
|
---|
1726 |
|
---|
1727 | RegisterOption("VssTree.epsilon", optFloat, "kd_eps=", "1e-6");
|
---|
1728 | RegisterOption("VssTree.ct_div_ci", optFloat, "kd_ctdivci=", "1.0");
|
---|
1729 | RegisterOption("VssTree.randomize", optBool, "randomize", "false");
|
---|
1730 | RegisterOption("VssTree.splitType", optString, "split=", "queries");
|
---|
1731 | RegisterOption("VssTree.splitUseOnlyDrivingAxis", optBool, "splitdriving=", "false");
|
---|
1732 | RegisterOption("VssTree.useRss", optBool, "rss=", "false");
|
---|
1733 | RegisterOption("VssTree.numberOfEndPointDomains", optInt, "endpoints=", "10000");
|
---|
1734 |
|
---|
1735 | RegisterOption("VssTree.minSize", optFloat, "minsize=", "0.001");
|
---|
1736 |
|
---|
1737 | RegisterOption("VssTree.maxTotalMemory", optFloat, "mem=", "60.0");
|
---|
1738 | RegisterOption("VssTree.maxStaticMemory", optFloat, "statmem=", "8.0");
|
---|
1739 |
|
---|
1740 | RegisterOption("VssTree.queryType", optString, "qtype=", "static");
|
---|
1741 |
|
---|
1742 |
|
---|
1743 |
|
---|
1744 | RegisterOption("VssTree.queryPosWeight", optFloat, "qposweight=", "0.0");
|
---|
1745 | RegisterOption("VssTree.useRefDirSplits", optBool, "refdir", "false");
|
---|
1746 | RegisterOption("VssTree.refDirAngle", optFloat, "refangle=", "10");
|
---|
1747 | RegisterOption("VssTree.refDirBoxMaxSize", optFloat, "refboxsize=", "0.1");
|
---|
1748 | RegisterOption("VssTree.accessTimeThreshold", optInt, "accesstime=", "1000");
|
---|
1749 | RegisterOption("VssTree.minCollapseDepth", optInt, "colldepth=", "4");
|
---|
1750 |
|
---|
1751 | RegisterOption("VssTree.interleaveDirSplits", optBool, "interleavedirsplits", "true");
|
---|
1752 | RegisterOption("VssTree.dirSplitDepth", optInt, "dirsplidepth=", "10");
|
---|
1753 |
|
---|
1754 |
|
---|
1755 | RegisterOption("RssPreprocessor.initialSamples",
|
---|
1756 | optInt,
|
---|
1757 | "initial_samples=",
|
---|
1758 | "100000");
|
---|
1759 |
|
---|
1760 | RegisterOption("RssPreprocessor.vssSamples",
|
---|
1761 | optInt,
|
---|
1762 | "rss_vss_samples=",
|
---|
1763 | "1000000");
|
---|
1764 |
|
---|
1765 | RegisterOption("RssPreprocessor.vssSamplesPerPass",
|
---|
1766 | optInt,
|
---|
1767 | "rss_vss_samples_per_pass=",
|
---|
1768 | "1000");
|
---|
1769 |
|
---|
1770 | RegisterOption("RssPreprocessor.samplesPerPass",
|
---|
1771 | optInt,
|
---|
1772 | "rss_samples_per_pass=",
|
---|
1773 | "100000");
|
---|
1774 |
|
---|
1775 | RegisterOption("RssPreprocessor.useImportanceSampling",
|
---|
1776 | optBool,
|
---|
1777 | "rss_use_importance",
|
---|
1778 | "true");
|
---|
1779 |
|
---|
1780 | RegisterOption("RssPreprocessor.objectBasedSampling",
|
---|
1781 | optBool,
|
---|
1782 | "rss_object_based_sampling",
|
---|
1783 | "true");
|
---|
1784 |
|
---|
1785 | RegisterOption("RssPreprocessor.directionalSampling",
|
---|
1786 | optBool,
|
---|
1787 | "rss_directional_sampling",
|
---|
1788 | "false");
|
---|
1789 |
|
---|
1790 | RegisterOption("RssTree.maxDepth", optInt, "kd_depth=", "12");
|
---|
1791 | RegisterOption("RssTree.minPvs", optInt, "kd_minpvs=", "1");
|
---|
1792 | RegisterOption("RssTree.minRays", optInt, "kd_minrays=", "10");
|
---|
1793 | RegisterOption("RssTree.maxCostRatio", optFloat, "maxcost=", "0.95");
|
---|
1794 | RegisterOption("RssTree.maxRayContribution", optFloat, "maxraycontrib=", "0.5");
|
---|
1795 |
|
---|
1796 | RegisterOption("RssTree.epsilon", optFloat, "kd_eps=", "1e-6");
|
---|
1797 | RegisterOption("RssTree.ct_div_ci", optFloat, "kd_ctdivci=", "1.0");
|
---|
1798 | RegisterOption("RssTree.randomize", optBool, "randomize", "false");
|
---|
1799 | RegisterOption("RssTree.splitType", optString, "split=", "queries");
|
---|
1800 | RegisterOption("RssTree.splitUseOnlyDrivingAxis", optBool, "splitdriving=", "false");
|
---|
1801 |
|
---|
1802 | RegisterOption("RssTree.numberOfEndPointDomains", optInt, "endpoints=", "10000");
|
---|
1803 |
|
---|
1804 | RegisterOption("RssTree.minSize", optFloat, "minsize=", "0.001");
|
---|
1805 |
|
---|
1806 | RegisterOption("RssTree.maxTotalMemory", optFloat, "mem=", "60.0");
|
---|
1807 | RegisterOption("RssTree.maxStaticMemory", optFloat, "statmem=", "8.0");
|
---|
1808 |
|
---|
1809 | RegisterOption("RssTree.queryType", optString, "qtype=", "static");
|
---|
1810 |
|
---|
1811 | RegisterOption("RssTree.queryPosWeight", optFloat, "qposweight=", "0.0");
|
---|
1812 | RegisterOption("RssTree.useRefDirSplits", optBool, "refdir", "false");
|
---|
1813 | RegisterOption("RssTree.refDirAngle", optFloat, "refangle=", "10");
|
---|
1814 | RegisterOption("RssTree.refDirBoxMaxSize", optFloat, "refboxsize=", "0.1");
|
---|
1815 | RegisterOption("RssTree.accessTimeThreshold", optInt, "accesstime=", "1000");
|
---|
1816 | RegisterOption("RssTree.minCollapseDepth", optInt, "colldepth=", "4");
|
---|
1817 |
|
---|
1818 | RegisterOption("RssTree.interleaveDirSplits", optBool, "interleavedirsplits", "true");
|
---|
1819 | RegisterOption("RssTree.dirSplitDepth", optInt, "dirsplidepth=", "10");
|
---|
1820 | RegisterOption("RssTree.importanceBasedCost", optBool, "importance_based_cost", "true");
|
---|
1821 | RegisterOption("RssTree.maxRays", optInt, "rss_max_rays=", "2000000");
|
---|
1822 |
|
---|
1823 | RegisterOption("RssTree.perObjectTree", optBool, "rss_per_object_tree", "false");
|
---|
1824 |
|
---|
1825 | RegisterOption("RssPreprocessor.Export.pvs", optBool, "rss_export_pvs", "false");
|
---|
1826 | RegisterOption("RssPreprocessor.Export.rssTree", optBool, "rss_export_rss_tree", "false");
|
---|
1827 | RegisterOption("RssPreprocessor.Export.rays", optBool, "rss_export_rays", "false");
|
---|
1828 | RegisterOption("RssPreprocessor.Export.numRays", optInt, "rss_export_num_rays=", "5000");
|
---|
1829 | RegisterOption("RssPreprocessor.useViewcells", optBool, "rss_use_viewcells", "false");
|
---|
1830 | RegisterOption("RssPreprocessor.updateSubdivision",
|
---|
1831 | optBool,
|
---|
1832 | "rss_update_subdivision",
|
---|
1833 | "false");
|
---|
1834 |
|
---|
1835 |
|
---|
1836 | /************************************************************************************/
|
---|
1837 | /* View space partition BSP tree related options */
|
---|
1838 | /************************************************************************************/
|
---|
1839 |
|
---|
1840 |
|
---|
1841 | RegisterOption("RssPreprocessor.loadInitialSamples",
|
---|
1842 | optBool,
|
---|
1843 | "vss_load_loadInitialSamples=",
|
---|
1844 | "false");
|
---|
1845 |
|
---|
1846 | RegisterOption("RssPreprocessor.storeInitialSamples",
|
---|
1847 | optBool,
|
---|
1848 | "vss_store_storeInitialSamples=",
|
---|
1849 | "false");
|
---|
1850 |
|
---|
1851 |
|
---|
1852 | /************************************************************************************/
|
---|
1853 | /* View space partition BSP tree related options */
|
---|
1854 | /************************************************************************************/
|
---|
1855 |
|
---|
1856 | RegisterOption("VspBspTree.Termination.minGlobalCostRatio",
|
---|
1857 | optFloat,
|
---|
1858 | "vsp_bsp_term_min_global_cost_ratio",
|
---|
1859 | "0.0001");
|
---|
1860 |
|
---|
1861 | RegisterOption("VspBspTree.useSplitCostQueue",
|
---|
1862 | optBool,
|
---|
1863 | "vsp_bsp_use_split_cost_queue=",
|
---|
1864 | "true");
|
---|
1865 |
|
---|
1866 | RegisterOption("VspBspTree.Termination.globalCostMissTolerance",
|
---|
1867 | optInt,
|
---|
1868 | "vsp_bsp_term_global_cost_miss_tolerance",
|
---|
1869 | "4");
|
---|
1870 |
|
---|
1871 | RegisterOption("VspBspTree.Termination.minPolygons",
|
---|
1872 | optInt,
|
---|
1873 | "vsp_bsp_term_min_polygons=",
|
---|
1874 | "5");
|
---|
1875 |
|
---|
1876 | RegisterOption("VspBspTree.Termination.minPvs",
|
---|
1877 | optInt,
|
---|
1878 | "vsp_bsp_term_min_pvs=",
|
---|
1879 | "20");
|
---|
1880 |
|
---|
1881 | RegisterOption("VspBspTree.Termination.minProbability",
|
---|
1882 | optFloat,
|
---|
1883 | "vsp_bsp_term_min_probability=",
|
---|
1884 | "0.001");
|
---|
1885 |
|
---|
1886 | RegisterOption("VspBspTree.subdivisionStats",
|
---|
1887 | optString,
|
---|
1888 | "vsp_bsp_subdivision_stats=",
|
---|
1889 | "vspBspSubdivisionStats.log");
|
---|
1890 |
|
---|
1891 | RegisterOption("VspBspTree.Termination.maxRayContribution",
|
---|
1892 | optFloat,
|
---|
1893 | "vsp_bsp_term_ray_contribution=",
|
---|
1894 | "0.005");
|
---|
1895 |
|
---|
1896 | RegisterOption("VspBspTree.Termination.minAccRayLenght",
|
---|
1897 | optFloat,
|
---|
1898 | "vsp_bsp_term_min_acc_ray_length=",
|
---|
1899 | "50");
|
---|
1900 |
|
---|
1901 | RegisterOption("VspBspTree.Termination.minRays",
|
---|
1902 | optInt,
|
---|
1903 | "vsp_bsp_term_min_rays=",
|
---|
1904 | "-1");
|
---|
1905 |
|
---|
1906 | RegisterOption("VspBspTree.Termination.ct_div_ci",
|
---|
1907 | optFloat,
|
---|
1908 | "vsp_bsp_term_ct_div_ci=",
|
---|
1909 | "0.0");
|
---|
1910 |
|
---|
1911 | RegisterOption("VspBspTree.Termination.maxDepth",
|
---|
1912 | optInt,
|
---|
1913 | "vsp_bsp_term_max_depth=",
|
---|
1914 | "100");
|
---|
1915 |
|
---|
1916 | RegisterOption("VspBspTree.Termination.AxisAligned.maxCostRatio",
|
---|
1917 | optFloat,
|
---|
1918 | "vsp_bsp_term_axis_aligned_max_cost_ratio=",
|
---|
1919 | "1.5");
|
---|
1920 |
|
---|
1921 | RegisterOption("VspBspTree.useCostHeuristics",
|
---|
1922 | optBool,
|
---|
1923 | "vsp_bsp_use_cost_heuristics=",
|
---|
1924 | "false");
|
---|
1925 |
|
---|
1926 | RegisterOption("VspBspTree.Termination.maxViewCells",
|
---|
1927 | optInt,
|
---|
1928 | "vsp_bsp_term_max_view_cells=",
|
---|
1929 | "1000");
|
---|
1930 |
|
---|
1931 | RegisterOption("VspBspTree.Termination.maxCostRatio",
|
---|
1932 | optFloat,
|
---|
1933 | "vsp_bsp_term_max_cost_ratio=",
|
---|
1934 | "1.5");
|
---|
1935 |
|
---|
1936 | RegisterOption("VspBspTree.Termination.missTolerance",
|
---|
1937 | optInt,
|
---|
1938 | "vsp_bsp_term_miss_tolerance=",
|
---|
1939 | "4");
|
---|
1940 | RegisterOption("VspBspTree.splitPlaneStrategy",
|
---|
1941 | optString,
|
---|
1942 | "vsp_bsp_split_method=",
|
---|
1943 | "leastSplits");
|
---|
1944 |
|
---|
1945 | RegisterOption("VspBspTree.maxPolyCandidates",
|
---|
1946 | optInt,
|
---|
1947 | "vsp_bsp_max_poly_candidates=",
|
---|
1948 | "20");
|
---|
1949 | RegisterOption("VspBspTree.maxRayCandidates",
|
---|
1950 | optInt,
|
---|
1951 | "vsp_bsp_max_plane_candidates=",
|
---|
1952 | "20");
|
---|
1953 |
|
---|
1954 | RegisterOption("VspBspTree.maxTests",
|
---|
1955 | optInt,
|
---|
1956 | "vsp_bsp_max_tests=",
|
---|
1957 | "5000");
|
---|
1958 |
|
---|
1959 | RegisterOption("VspBspTree.Construction.samples",
|
---|
1960 | optInt,
|
---|
1961 | "bsp_construction_samples=",
|
---|
1962 | "100000");
|
---|
1963 |
|
---|
1964 | RegisterOption("VspBspTree.Construction.epsilon",
|
---|
1965 | optFloat,
|
---|
1966 | "vsp_bsp_construction_side_tolerance=",
|
---|
1967 | "0.002");
|
---|
1968 |
|
---|
1969 | RegisterOption("VspBspTree.Visualization.exportSplits",
|
---|
1970 | optBool,
|
---|
1971 | "vsp_bsp_visualization.export_splits",
|
---|
1972 | "false");
|
---|
1973 |
|
---|
1974 | RegisterOption("VspBspTree.splitUseOnlyDrivingAxis",
|
---|
1975 | optBool,
|
---|
1976 | "vsp_bsp_split_only_driving_axis=",
|
---|
1977 | "false");
|
---|
1978 |
|
---|
1979 | RegisterOption("VspBspTree.usePolygonSplitIfAvailable",
|
---|
1980 | optBool,
|
---|
1981 | "vsp_bsp_usePolygonSplitIfAvailable=",
|
---|
1982 | "false");
|
---|
1983 |
|
---|
1984 | RegisterOption("VspBspTree.Termination.AxisAligned.minRays",
|
---|
1985 | optInt,
|
---|
1986 | "bsp_term_axis_aligned_min_rays=",
|
---|
1987 | "100");
|
---|
1988 |
|
---|
1989 | RegisterOption("VspBspTree.Termination.AxisAligned.maxRayContribution",
|
---|
1990 | optFloat,
|
---|
1991 | "bsp_term_axis_aligned_min_rays=",
|
---|
1992 | "0.1");
|
---|
1993 |
|
---|
1994 | RegisterOption("VspBspTree.Factor.leastRaySplits", optFloat, "-vsp_bsp_factor_least_ray_splits=", "1.0");
|
---|
1995 | RegisterOption("VspBspTree.Factor.balancedRays", optFloat, "-vsp_bsp_factor_balanced_rays=", "1.0");
|
---|
1996 | RegisterOption("VspBspTree.Factor.pvs", optFloat, "-vsp_bsp_factor_pvs=", "1.0");
|
---|
1997 |
|
---|
1998 | RegisterOption("VspBspTree.Construction.renderCostWeight",
|
---|
1999 | optFloat,
|
---|
2000 | "-vsp_bsp_post_process_render_cost_weight",
|
---|
2001 | "0.5");
|
---|
2002 |
|
---|
2003 | RegisterOption("VspBspTree.Construction.randomize",
|
---|
2004 | optBool,
|
---|
2005 | "vsp_bsp_construction_randomize=",
|
---|
2006 | "false");
|
---|
2007 |
|
---|
2008 | RegisterOption("VspBspTree.simulateOctree",
|
---|
2009 | optBool,
|
---|
2010 | "vsp_bsp_simulate_octree=",
|
---|
2011 | "false");
|
---|
2012 |
|
---|
2013 | RegisterOption("VspBspTree.useBreathFirstSplits",
|
---|
2014 | optBool,
|
---|
2015 | "vsp_bsp_breath_first_splits=",
|
---|
2016 | "false");
|
---|
2017 |
|
---|
2018 | RegisterOption("VspBspTree.useRandomAxis",
|
---|
2019 | optBool,
|
---|
2020 | "-vsp_bsp_use_random_axis=",
|
---|
2021 | "false");
|
---|
2022 |
|
---|
2023 | RegisterOption("VspBspTree.maxTotalMemory",
|
---|
2024 | optFloat,
|
---|
2025 | "vsp_bsp_max_total_mem=",
|
---|
2026 | "60.0");
|
---|
2027 |
|
---|
2028 | RegisterOption("VspBspTree.maxStaticMemory",
|
---|
2029 | optFloat,
|
---|
2030 | "vsp_bsp_max_static_mem=",
|
---|
2031 | "8.0");
|
---|
2032 |
|
---|
2033 |
|
---|
2034 |
|
---|
2035 |
|
---|
2036 | //////////////////////////////////////////////////////////////////////////////////
|
---|
2037 | }
|
---|
2038 |
|
---|
2039 | void
|
---|
2040 | Environment::SetStaticOptions()
|
---|
2041 | {
|
---|
2042 |
|
---|
2043 | // get Global option values
|
---|
2044 | GetRealValue("Limits.threshold", Limits::Threshold);
|
---|
2045 | GetRealValue("Limits.small", Limits::Small);
|
---|
2046 | GetRealValue("Limits.infinity", Limits::Infinity);
|
---|
2047 |
|
---|
2048 |
|
---|
2049 | }
|
---|
2050 |
|
---|
2051 | void
|
---|
2052 | Environment::Parse(const int argc, char **argv, bool useExePath)
|
---|
2053 | {
|
---|
2054 |
|
---|
2055 | // Read the names of the scene, environment and output files
|
---|
2056 | ReadCmdlineParams(argc, argv, "");
|
---|
2057 |
|
---|
2058 | char *envFilename = new char[128];
|
---|
2059 |
|
---|
2060 | char filename[64];
|
---|
2061 |
|
---|
2062 | // Get the environment file name
|
---|
2063 | if (!GetParam(' ', 0, filename)) {
|
---|
2064 | // user didn't specified environment file explicitly, so
|
---|
2065 | strcpy(filename, "default.env");
|
---|
2066 | }
|
---|
2067 |
|
---|
2068 | if (useExePath) {
|
---|
2069 | char *path = GetPath(argv[0]);
|
---|
2070 | if (*path != 0)
|
---|
2071 | sprintf(envFilename, "%s/%s", path, filename);
|
---|
2072 | else
|
---|
2073 | strcpy(envFilename, filename);
|
---|
2074 |
|
---|
2075 | delete path;
|
---|
2076 | }
|
---|
2077 | else
|
---|
2078 | strcpy(envFilename, filename);
|
---|
2079 |
|
---|
2080 |
|
---|
2081 | // Now it's time to read in environment file.
|
---|
2082 | if (!ReadEnvFile(envFilename)) {
|
---|
2083 | // error - bad input file name specified ?
|
---|
2084 | cerr<<"Error parsing environment file "<<envFilename<<endl;
|
---|
2085 | }
|
---|
2086 | delete envFilename;
|
---|
2087 |
|
---|
2088 | // Parse the command line; options given on the command line subsume
|
---|
2089 | // stuff specified in the input environment file.
|
---|
2090 | ParseCmdline(argc, argv, 0);
|
---|
2091 |
|
---|
2092 | SetStaticOptions();
|
---|
2093 |
|
---|
2094 | // Check for request for help
|
---|
2095 | if (CheckForSwitch(argc, argv, '?')) {
|
---|
2096 | PrintUsage(cout);
|
---|
2097 | exit(0);
|
---|
2098 | }
|
---|
2099 |
|
---|
2100 | }
|
---|