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

Revision 1074, 58.2 KB checked in by mattausch, 18 years ago (diff)

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