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

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