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

Revision 2524, 74.4 KB checked in by bittner, 18 years ago (diff)

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