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

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