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

Revision 1006, 55.2 KB checked in by mattausch, 18 years ago (diff)

started viewspace-objectspace subdivision
removed memory leaks
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.Filter.maxSize",
1317                                        optInt,
1318                                        "view_cells_filter_max_size=",
1319                                        "4");
1320
1321        RegisterOption("ViewCells.Filter.width",
1322                                        optFloat,
1323                                        "view_cells_filter_width=",
1324                                        "200.0");
1325
1326        RegisterOption("ViewCells.loadFromFile",
1327                                        optBool,
1328                                        "view_cells_load_from_file=",
1329                                        "false");
1330
1331        RegisterOption("ViewCells.PostProcess.refine",
1332                                        optBool,
1333                                        "view_cells_refine=",
1334                                        "false");
1335
1336        RegisterOption("ViewCells.PostProcess.compress",
1337                                        optBool,
1338                                        "view_cells_post_process_compress=",
1339                                        "false");
1340
1341        RegisterOption("ViewCells.Evaluation.samples",
1342                                        optInt,
1343                                        "view_cells_evaluation_samples=",
1344                                        "8000000");
1345
1346        RegisterOption("ViewCells.Evaluation.samplingType",
1347                                        optString,
1348                                        "view_cells_evaluation_sampling_type=",
1349                                        "box");
1350
1351        RegisterOption("ViewCells.Evaluation.samplesPerPass",
1352                                        optInt,
1353                                        "view_cells_evaluation_samples_per_pass=",
1354                                        "300000");
1355
1356        RegisterOption("ViewCells.exportToFile",
1357                                        optBool,
1358                                        "view_cells_export_to_file=",
1359                                        "false");
1360
1361        RegisterOption("ViewCells.exportPvs",
1362                                        optBool,
1363                                        "view_cells_export_pvs=",
1364                                        "false");
1365
1366        RegisterOption("ViewCells.exportBboxesForPvs",
1367                                        optBool,
1368                                        "view_cells_export_bounding_boxes=",
1369                                        "true");
1370       
1371        RegisterOption("ViewCells.boxesFilename",
1372                                        optString,
1373                                        "view_cells_boxes_filename=",
1374                                        "boxes.out");
1375
1376        RegisterOption("ViewCells.evaluateViewCells",
1377                                        optBool,
1378                                        "view_cells_evaluate=",
1379                                        "false");
1380
1381        RegisterOption("ViewCells.maxViewCells",
1382                                        optInt,
1383                                        "view_cells_max_view_cells=",
1384                                        "0");
1385
1386        RegisterOption("ViewCells.maxPvsRatio",
1387                                        optFloat,
1388                                        "view_cells_max_pvs_ratio=",
1389                                        "0.1");
1390
1391        RegisterOption("ViewCells.filename",
1392                                        optString,
1393                                        "view_cells_filename=",
1394                                        "atlanta_viewcells_large.x3d");
1395
1396        RegisterOption("ViewCells.height",
1397                                        optFloat,
1398                                        "view_cells_height=",
1399                                        "5.0");
1400
1401        RegisterOption("ViewCells.Visualization.colorCode",
1402                                        optString,
1403                                        "view_cells_visualization_color_code=",
1404                                        "PVS");
1405
1406        RegisterOption("ViewCells.Visualization.clipPlanePos",
1407                                        optFloat,
1408                                        "view_cells_visualization_clip_plane_pos=",
1409                                        "0.35");
1410       
1411        RegisterOption("ViewCells.Visualization.exportGeometry",
1412                                        optBool,
1413                                        "view_cells_visualization_export_geometry=",
1414                                        "false");
1415
1416        RegisterOption("ViewCells.Visualization.exportRays",
1417                                        optBool,
1418                                        "view_cells_visualization_export_rays=",
1419                                        "false");
1420
1421        RegisterOption("ViewCells.pruneEmptyViewCells",
1422                                        optBool,
1423                                        "view_cells_prune_empty=",
1424                                        "false");
1425
1426        RegisterOption("ViewCells.processOnlyValidViewCells",
1427                                        optBool,
1428                                        "view_cells_process_only_valid_view_cells=",
1429                                        "false");
1430
1431       
1432        RegisterOption("ViewCells.PostProcess.maxCostRatio",
1433                        optFloat,
1434                        "view_cells_post_process_max_cost_ratio=",
1435                        "0.9");
1436       
1437        RegisterOption("ViewCells.PostProcess.renderCostWeight",
1438                        optFloat,
1439                        "view_cells_post_process_render_cost_weight",
1440                        "0.5");
1441       
1442        RegisterOption("ViewCells.PostProcess.avgCostMaxDeviation",
1443                        optFloat,
1444                        "vsp_bsp_avgcost_max_deviations",
1445                        "0.5");
1446
1447        RegisterOption("ViewCells.PostProcess.maxMergesPerPass",
1448                optInt,
1449                "view_cells_post_process_max_merges_per_pass=",
1450                "500");
1451
1452        RegisterOption("ViewCells.PostProcess.minViewCells",
1453                optInt,
1454                "view_cells_post_process_min_view_cells=",
1455                "1000");
1456
1457        RegisterOption("ViewCells.PostProcess.useRaysForMerge",
1458                optBool,
1459                "view_cells_post_process_use_rays_for_merge=",
1460                "false");
1461       
1462        RegisterOption("ViewCells.PostProcess.merge",
1463                optBool,
1464                "view_cells_post_process_merge=",
1465                "true");
1466
1467        RegisterOption("ViewCells.Visualization.exportMergedViewCells",
1468                optBool,
1469                "view_cells_viz_export_merged_viewcells=",
1470                "false");
1471
1472        RegisterOption("ViewCells.maxStaticMemory",
1473                optFloat,
1474                "view_cells_max_static_mem=",
1475                "8.0");
1476
1477        RegisterOption("ViewCells.Visualization.useClipPlane",
1478                optBool,
1479                "view_cells_viz_use_clip_plane=",
1480                "false");
1481       
1482        RegisterOption("ViewCells.showVisualization",
1483                optBool,
1484                "view_cells_show_visualization=",
1485                "false");
1486
1487        RegisterOption("ViewCells.Visualization.clipPlaneAxis",
1488                optInt,
1489                "view_cells_viz_clip_plane_axis=",
1490                "0");
1491
1492
1493        /************************************************************************************/
1494        /*                         Render simulation related options                        */
1495        /************************************************************************************/
1496
1497
1498        RegisterOption("Simulation.objRenderCost",
1499                        optFloat,
1500                        "simulation_obj_render_cost",
1501                        "1.0");
1502
1503        RegisterOption("Simulation.vcOverhead",
1504                        optFloat,
1505                        "simulation_vc_overhead",
1506                        "0.05");
1507
1508        RegisterOption("Simulation.moveSpeed",
1509                        optFloat,
1510                        "simulation_moveSpeed",
1511                        "1.0");
1512
1513
1514
1515
1516        /************************************************************************************/
1517        /*                         Bsp tree related options                                 */
1518        /************************************************************************************/
1519
1520
1521        RegisterOption("BspTree.Construction.input",
1522                optString,
1523                "bsp_construction_input=",
1524                "fromViewCells");
1525
1526        RegisterOption("BspTree.subdivisionStats",
1527                                        optString,
1528                                        "bsp_subdivision_stats=",
1529                                        "bspSubdivisionStats.log");
1530
1531        RegisterOption("BspTree.Construction.samples",
1532                optInt,
1533                "bsp_construction_samples=",
1534                "100000");
1535
1536        RegisterOption("BspTree.Construction.epsilon",
1537                optFloat,
1538                "bsp_construction_side_tolerance=",
1539                "0.002");
1540
1541        RegisterOption("BspTree.Termination.minPolygons",
1542                        optInt,
1543                        "bsp_term_min_polygons=",
1544                        "5");
1545
1546        RegisterOption("BspTree.Termination.minPvs",
1547                        optInt,
1548                        "bsp_term_min_pvs=",
1549                        "20");
1550
1551        RegisterOption("BspTree.Termination.minProbability",
1552                        optFloat,
1553                        "bsp_term_min_probability=",
1554                        "0.001");
1555
1556        RegisterOption("BspTree.Termination.maxRayContribution",
1557                        optFloat,
1558                        "bsp_term_ray_contribution=",
1559                        "0.005");
1560
1561        RegisterOption("BspTree.Termination.minAccRayLenght",
1562                        optFloat,
1563                        "bsp_term_min_acc_ray_length=",
1564                        "50");
1565
1566        RegisterOption("BspTree.Termination.minRays",
1567                        optInt,
1568                        "bsp_term_min_rays=",
1569                        "-1");
1570
1571        RegisterOption("BspTree.Termination.ct_div_ci",
1572                        optFloat,
1573                        "bsp_term_ct_div_ci=",
1574                        "0.0");
1575
1576        RegisterOption("BspTree.Termination.maxDepth",
1577                        optInt,
1578                        "bsp_term_max_depth=",
1579                        "100");
1580
1581        RegisterOption("BspTree.Termination.maxCostRatio",
1582                        optFloat,
1583                        "bsp_term_axis_aligned_max_cost_ratio=",
1584                        "1.5");
1585
1586        RegisterOption("BspTree.Termination.AxisAligned.ct_div_ci",
1587                        optFloat,
1588                        "bsp_term_axis_aligned_ct_div_ci=",
1589                        "0.5");
1590
1591        RegisterOption("BspTree.AxisAligned.splitBorder",
1592                        optFloat,
1593                        "bsp__axis_aligned_split_border=",
1594                        "0.1");
1595
1596        RegisterOption("BspTree.Termination.AxisAligned.minPolys",
1597                        optInt,
1598                        "bsp_term_axis_aligned_max_polygons=",
1599                        "50");
1600
1601        RegisterOption("BspTree.Termination.AxisAligned.minObjects",
1602                        optInt,
1603                        "bsp_term_min_objects=",
1604                        "3");
1605
1606        RegisterOption("BspTree.Termination.AxisAligned.minRays",
1607                        optInt,
1608                        "bsp_term_axis_aligned_min_rays=",
1609                        "-1");
1610
1611        RegisterOption("BspTree.splitPlaneStrategy",
1612                        optString,
1613                        "bsp_split_method=",
1614                        "leastSplits");
1615
1616        RegisterOption("BspTree.maxPolyCandidates",
1617                optInt,
1618                "bsp_max_poly_candidates=",
1619                "20");
1620
1621        RegisterOption("BspTree.maxRayCandidates",
1622                optInt,
1623                "bsp_max_plane_candidates=",
1624                "20");
1625
1626        RegisterOption("BspTree.maxTests",
1627                optInt,
1628                "bsp_max_tests=",
1629                "5000");
1630
1631        RegisterOption("BspTree.Termination.maxViewCells",
1632                optInt,
1633                "bsp_max_view_cells=",
1634                "5000");
1635
1636        RegisterOption("BspTree.Visualization.exportSplits",
1637                optBool,
1638                "bsp_visualization.export_splits",
1639                "false");
1640
1641        RegisterOption("BspTree.Factor.verticalSplits", optFloat, "bsp_factor_vertical=", "1.0");
1642        RegisterOption("BspTree.Factor.largestPolyArea", optFloat, "bsp_factor_largest_poly=", "1.0");
1643        RegisterOption("BspTree.Factor.blockedRays", optFloat, "bsp_factor_blocked=", "1.0");
1644        RegisterOption("BspTree.Factor.leastSplits", optFloat, "bsp_factor_least_splits=", "1.0");
1645        RegisterOption("BspTree.Factor.balancedPolys", optFloat, "bsp_factor_balanced_polys=", "1.0");
1646        RegisterOption("BspTree.Factor.balancedViewCells", optFloat, "bsp_factor_balanced_view_cells=", "1.0");
1647        RegisterOption("BspTree.Factor.leastRaySplits", optFloat, "bsp_factor_least_ray_splits=", "1.0");
1648        RegisterOption("BspTree.Factor.balancedRays", optFloat, "bsp_factor_balanced_rays=", "1.0");
1649        RegisterOption("BspTree.Factor.pvs", optFloat, "bsp_factor_pvs=", "1.0");
1650
1651        /************************************************************************************/
1652        /*                         Preprocessor related options                             */
1653        /************************************************************************************/
1654
1655        RegisterOption("Preprocessor.type",
1656                                        optString,
1657                                        "preprocessor=",
1658                                        "sampling");
1659
1660        RegisterOption("Preprocessor.samplesFilename",
1661                                        optString,
1662                                        "preprocessor_samples_filename=",
1663                                        "rays.out");
1664
1665        RegisterOption("Preprocessor.loadPolygonsAsMeshes",
1666                                        optBool,
1667                                        "loadPolygonsAsMeshes=",
1668                                        "false");
1669
1670        RegisterOption("Preprocessor.pvsRenderErrorSamples",
1671                                   optInt,
1672                                   "pvsRenderErrorSamples=",
1673                                   "10000");
1674       
1675        RegisterOption("Preprocessor.useGlRenderer",
1676                                        optBool,
1677                                        "preprocessor_use_gl_renderer=",
1678                                        "false");
1679
1680        RegisterOption("Preprocessor.useGlDebugger",
1681                                        optBool,
1682                                        "preprocessor_use_gl_debugger=",
1683                                        "false");
1684
1685        RegisterOption("Preprocessor.detectEmptyViewSpace",
1686                                   optBool,
1687                                   "preprocessor_detect_empty_viewspace=",
1688                                   "false");
1689       
1690        RegisterOption("Preprocessor.quitOnFinish",
1691                                   optBool,
1692                                   "preprocessor_quit_on_finish=",
1693                                   "true");
1694
1695        RegisterOption("Preprocessor.computeVisibility",
1696                                   optBool,
1697                                   "preprocessor_compute_visibility=",
1698                                   "true");
1699
1700        RegisterOption("Preprocessor.exportVisibility",
1701                                   optBool,
1702                                   "preprocessor_export_visibility=",
1703                                   "true");
1704
1705        RegisterOption("Preprocessor.visibilityFile",
1706                                   optString,
1707                                   "preprocessor_visibility_file=",
1708                                   "visibility.xml");
1709
1710        RegisterOption("Preprocessor.applyVisibilityFilter",
1711                                   optBool,
1712                                   "preprocessor_apply_filter=",
1713                                   "true");
1714       
1715        RegisterOption("Preprocessor.applyVisibilitySpatialFilter",
1716                                   optBool,
1717                                   "preprocessor_apply_spatial_filter=",
1718                                   "true");
1719
1720        RegisterOption("Preprocessor.visibilityFilterWidth",
1721                                   optFloat,
1722                                   "preprocessor_visibility_filter_width=",
1723                                   "0.02");
1724
1725        RegisterOption("Preprocessor.histogram.maxValue",
1726                                        optInt,
1727                                        "preprocessor_histogram_max_value=",
1728                                        "1000");
1729
1730        RegisterOption("Preprocessor.histogram.intervals",
1731                                        optInt,
1732                                        "preprocessor_histogram_intervals=",
1733                                        "20");
1734
1735
1736        /************************************************************************************/
1737        /*                   VSS Preprocessor cells related options                         */
1738        /************************************************************************************/
1739
1740        RegisterOption("VssTree.maxDepth", optInt, "kd_depth=", "12");
1741        RegisterOption("VssTree.minPvs", optInt, "kd_minpvs=", "1");
1742        RegisterOption("VssTree.minRays", optInt, "kd_minrays=", "10");
1743        RegisterOption("VssTree.maxCostRatio", optFloat, "maxcost=", "0.95");
1744        RegisterOption("VssTree.maxRayContribution", optFloat, "maxraycontrib=", "0.5");
1745
1746        RegisterOption("VssTree.epsilon", optFloat, "kd_eps=", "1e-6");
1747        RegisterOption("VssTree.ct_div_ci", optFloat, "kd_ctdivci=", "1.0");
1748        RegisterOption("VssTree.randomize", optBool, "randomize", "false");
1749        RegisterOption("VssTree.splitType", optString, "split=", "queries");
1750        RegisterOption("VssTree.splitUseOnlyDrivingAxis", optBool, "splitdriving=", "false");
1751        RegisterOption("VssTree.useRss", optBool, "rss=", "false");
1752        RegisterOption("VssTree.numberOfEndPointDomains", optInt, "endpoints=", "10000");
1753
1754        RegisterOption("VssTree.minSize", optFloat, "minsize=", "0.001");
1755
1756        RegisterOption("VssTree.maxTotalMemory", optFloat, "mem=", "60.0");
1757        RegisterOption("VssTree.maxStaticMemory", optFloat, "statmem=", "8.0");
1758
1759        RegisterOption("VssTree.queryType", optString, "qtype=", "static");
1760
1761       
1762       
1763        RegisterOption("VssTree.queryPosWeight", optFloat, "qposweight=", "0.0");
1764        RegisterOption("VssTree.useRefDirSplits", optBool, "refdir=", "false");
1765        RegisterOption("VssTree.refDirAngle", optFloat, "refangle=", "10");
1766        RegisterOption("VssTree.refDirBoxMaxSize", optFloat, "refboxsize=", "0.1");
1767        RegisterOption("VssTree.accessTimeThreshold", optInt, "accesstime=", "1000");
1768        RegisterOption("VssTree.minCollapseDepth", optInt, "colldepth=", "4");
1769
1770        RegisterOption("VssTree.interleaveDirSplits", optBool, "interleavedirsplits", "true");
1771        RegisterOption("VssTree.dirSplitDepth", optInt, "dirsplidepth=", "10");
1772
1773
1774        RegisterOption("RssPreprocessor.initialSamples",
1775                                                                        optInt,
1776                                                                        "initial_samples=",
1777                                                                        "100000");
1778
1779        RegisterOption("RssPreprocessor.vssSamples",
1780                                        optInt,
1781                                        "rss_vss_samples=",
1782                                        "1000000");
1783
1784        RegisterOption("RssPreprocessor.vssSamplesPerPass",
1785                                        optInt,
1786                                        "rss_vss_samples_per_pass=",
1787                                        "1000");
1788
1789        RegisterOption("RssPreprocessor.samplesPerPass",
1790                                        optInt,
1791                                        "rss_samples_per_pass=",
1792                                        "100000");
1793
1794        RegisterOption("RssPreprocessor.useImportanceSampling",
1795                                        optBool,
1796                                        "rss_use_importance=",
1797                                        "true");
1798
1799        RegisterOption("RssPreprocessor.objectBasedSampling",
1800                                        optBool,
1801                                        "rss_object_based_sampling=",
1802                                        "true");
1803
1804        RegisterOption("RssPreprocessor.directionalSampling",
1805                                        optBool,
1806                                        "rss_directional_sampling=",
1807                                        "false");
1808
1809        RegisterOption("RssTree.maxDepth", optInt, "kd_depth=", "12");
1810        RegisterOption("RssTree.minPvs", optInt, "kd_minpvs=", "1");
1811        RegisterOption("RssTree.minRays", optInt, "kd_minrays=", "10");
1812        RegisterOption("RssTree.maxCostRatio", optFloat, "maxcost=", "0.95");
1813        RegisterOption("RssTree.maxRayContribution", optFloat, "maxraycontrib=", "0.5");
1814
1815        RegisterOption("RssTree.epsilon", optFloat, "kd_eps=", "1e-6");
1816        RegisterOption("RssTree.ct_div_ci", optFloat, "kd_ctdivci=", "1.0");
1817        RegisterOption("RssTree.randomize", optBool, "randomize=", "false");
1818        RegisterOption("RssTree.splitType", optString, "split=", "queries");
1819        RegisterOption("RssTree.splitUseOnlyDrivingAxis", optBool, "splitdriving=", "false");
1820
1821        RegisterOption("RssTree.numberOfEndPointDomains", optInt, "endpoints=", "10000");
1822
1823        RegisterOption("RssTree.minSize", optFloat, "minsize=", "0.001");
1824
1825        RegisterOption("RssTree.maxTotalMemory", optFloat, "mem=", "60.0");
1826        RegisterOption("RssTree.maxStaticMemory", optFloat, "statmem=", "8.0");
1827
1828        RegisterOption("RssTree.queryType", optString, "qtype=", "static");
1829
1830        RegisterOption("RssTree.queryPosWeight", optFloat, "qposweight=", "0.0");
1831        RegisterOption("RssTree.useRefDirSplits", optBool, "refdir", "false");
1832        RegisterOption("RssTree.refDirAngle", optFloat, "refangle=", "10");
1833        RegisterOption("RssTree.refDirBoxMaxSize", optFloat, "refboxsize=", "0.1");
1834        RegisterOption("RssTree.accessTimeThreshold", optInt, "accesstime=", "1000");
1835        RegisterOption("RssTree.minCollapseDepth", optInt, "colldepth=", "4");
1836
1837        RegisterOption("RssTree.interleaveDirSplits", optBool, "interleavedirsplits=", "true");
1838        RegisterOption("RssTree.dirSplitDepth", optInt, "dirsplidepth=", "10");
1839        RegisterOption("RssTree.importanceBasedCost", optBool, "importance_based_cost=", "true");
1840        RegisterOption("RssTree.maxRays", optInt, "rss_max_rays=", "2000000");
1841
1842        RegisterOption("RssTree.perObjectTree", optBool, "rss_per_object_tree", "false");
1843
1844        RegisterOption("RssPreprocessor.Export.pvs", optBool, "rss_export_pvs=", "false");
1845        RegisterOption("RssPreprocessor.Export.rssTree", optBool, "rss_export_rss_tree=", "false");
1846        RegisterOption("RssPreprocessor.Export.rays", optBool, "rss_export_rays=", "false");
1847        RegisterOption("RssPreprocessor.Export.numRays", optInt, "rss_export_num_rays=", "5000");
1848        RegisterOption("RssPreprocessor.useViewcells", optBool, "rss_use_viewcells=", "false");
1849        RegisterOption("RssPreprocessor.updateSubdivision",
1850                                   optBool,
1851                                   "rss_update_subdivision=",
1852                                   "false");
1853
1854
1855/************************************************************************************/
1856/*               View space partition BSP tree related options                      */
1857/************************************************************************************/
1858
1859
1860        RegisterOption("RssPreprocessor.loadInitialSamples",
1861                                        optBool,
1862                                        "vss_load_loadInitialSamples=",
1863                                        "false");
1864
1865        RegisterOption("RssPreprocessor.storeInitialSamples",
1866                                        optBool,
1867                                        "vss_store_storeInitialSamples=",
1868                                        "false");
1869
1870
1871/************************************************************************************/
1872/*               View space partition BSP tree related options                      */
1873/************************************************************************************/
1874
1875        RegisterOption("VspBspTree.Termination.minGlobalCostRatio",
1876                                        optFloat,
1877                                        "vsp_bsp_term_min_global_cost_ratio=",
1878                                        "0.0001");
1879
1880        RegisterOption("VspBspTree.useSplitCostQueue",
1881                optBool,
1882                "vsp_bsp_use_split_cost_queue=",
1883                "true");
1884
1885        RegisterOption("VspBspTree.Termination.globalCostMissTolerance",
1886                                        optInt,
1887                                        "vsp_bsp_term_global_cost_miss_tolerance=",
1888                                        "4");
1889
1890        RegisterOption("VspBspTree.Termination.minPolygons",
1891                                        optInt,
1892                                        "vsp_bsp_term_min_polygons=",
1893                                        "5");
1894
1895        RegisterOption("VspBspTree.Termination.minPvs",
1896                                        optInt,
1897                                        "vsp_bsp_term_min_pvs=",
1898                                        "20");
1899
1900        RegisterOption("VspBspTree.Termination.minProbability",
1901                                        optFloat,
1902                                        "vsp_bsp_term_min_probability=",
1903                                        "0.001");
1904
1905        RegisterOption("VspBspTree.subdivisionStats",
1906                                        optString,
1907                                        "vsp_bsp_subdivision_stats=",
1908                                        "vspBspSubdivisionStats.log");
1909
1910        RegisterOption("VspBspTree.Termination.maxRayContribution",
1911                                        optFloat,
1912                                        "vsp_bsp_term_ray_contribution=",
1913                                        "0.005");
1914
1915        RegisterOption("VspBspTree.Termination.minAccRayLenght",
1916                                        optFloat,
1917                                        "vsp_bsp_term_min_acc_ray_length=",
1918                                        "50");
1919
1920        RegisterOption("VspBspTree.Termination.minRays",
1921                                        optInt,
1922                                        "vsp_bsp_term_min_rays=",
1923                                        "-1");
1924
1925        RegisterOption("VspBspTree.Termination.ct_div_ci",
1926                                        optFloat,
1927                                        "vsp_bsp_term_ct_div_ci=",
1928                                        "0.0");
1929
1930        RegisterOption("VspBspTree.Termination.maxDepth",
1931                                        optInt,
1932                                        "vsp_bsp_term_max_depth=",
1933                                        "100");
1934
1935        RegisterOption("VspBspTree.Termination.AxisAligned.maxCostRatio",
1936                optFloat,
1937                "vsp_bsp_term_axis_aligned_max_cost_ratio=",
1938                "1.5");
1939
1940        RegisterOption("VspBspTree.useCostHeuristics",
1941                optBool,
1942                "vsp_bsp_use_cost_heuristics=",
1943                "false");
1944
1945        RegisterOption("VspBspTree.Termination.maxViewCells",
1946                optInt,
1947                "vsp_bsp_term_max_view_cells=",
1948                "10000");
1949
1950        RegisterOption("VspBspTree.Termination.maxCostRatio",
1951                optFloat,
1952                "vsp_bsp_term_max_cost_ratio=",
1953                "1.5");
1954
1955        RegisterOption("VspBspTree.Termination.missTolerance",
1956                optInt,
1957                "vsp_bsp_term_miss_tolerance=",
1958                "4");
1959
1960        RegisterOption("VspBspTree.splitPlaneStrategy",
1961                                        optString,
1962                                        "vsp_bsp_split_method=",
1963                                        "leastSplits");
1964
1965        RegisterOption("VspBspTree.maxPolyCandidates",
1966                                        optInt,
1967                                        "vsp_bsp_max_poly_candidates=",
1968                                        "20");
1969        RegisterOption("VspBspTree.maxRayCandidates",
1970                                        optInt,
1971                                        "vsp_bsp_max_plane_candidates=",
1972                                        "20");
1973
1974        RegisterOption("VspBspTree.maxTests",
1975                                        optInt,
1976                                        "vsp_bsp_max_tests=",
1977                                        "5000");
1978
1979        RegisterOption("VspBspTree.Construction.samples",
1980                                        optInt,
1981                                        "vsp_bsp_construction_samples=",
1982                                        "100000");
1983
1984        RegisterOption("VspBspTree.Construction.minBand",
1985                                        optFloat,
1986                                        "vsp_bsp_construction_min_band=",
1987                                        "0.1");
1988
1989        RegisterOption("VspBspTree.Construction.maxBand",
1990                                        optFloat,
1991                                        "vsp_bsp_construction_min_band=",
1992                                        "0.9");
1993
1994        RegisterOption("VspBspTree.Construction.useDrivingAxisForMaxCost",
1995                                        optBool,
1996                                        "vsp_bsp_construction_use_drivingaxis_for_maxcost=",
1997                                        "false");
1998
1999        RegisterOption("VspBspTree.Construction.epsilon",
2000                                        optFloat,
2001                                        "vsp_bsp_construction_side_tolerance=",
2002                                        "0.002");
2003
2004        RegisterOption("VspBspTree.Visualization.exportSplits",
2005                                        optBool,
2006                                        "vsp_bsp_visualization.export_splits",
2007                                        "false");
2008
2009        RegisterOption("VspBspTree.splitUseOnlyDrivingAxis",
2010                                        optBool,
2011                                        "vsp_bsp_split_only_driving_axis=",
2012                                        "false");
2013
2014        RegisterOption("VspBspTree.usePolygonSplitIfAvailable",
2015                                        optBool,
2016                    "vsp_bsp_usePolygonSplitIfAvailable=",
2017                                        "false");
2018
2019        RegisterOption("VspBspTree.Termination.AxisAligned.minRays",
2020                        optInt,
2021                        "bsp_term_axis_aligned_min_rays=",
2022                        "100");
2023       
2024        RegisterOption("VspBspTree.Termination.AxisAligned.maxRayContribution",
2025                        optFloat,
2026                        "bsp_term_axis_aligned_min_rays=",
2027                        "0.1");
2028
2029        RegisterOption("VspBspTree.Factor.leastRaySplits",
2030                                        optFloat,
2031                                        "vsp_bsp_factor_least_ray_splits=",
2032                                        "1.0");
2033
2034        RegisterOption("VspBspTree.Factor.balancedRays",
2035                                        optFloat,
2036                                        "vsp_bsp_factor_balanced_rays=",
2037                                        "1.0");
2038
2039        RegisterOption("VspBspTree.Factor.pvs",
2040                                        optFloat,
2041                                        "vsp_bsp_factor_pvs=",
2042                                        "1.0");
2043       
2044        RegisterOption("VspBspTree.Construction.renderCostWeight",
2045                        optFloat,
2046                        "vsp_bsp_post_process_render_cost_weight=",
2047                        "0.5");
2048
2049        RegisterOption("VspBspTree.Construction.randomize",
2050                optBool,
2051                "vsp_bsp_construction_randomize=",
2052                "false");
2053
2054        RegisterOption("VspBspTree.simulateOctree",
2055                optBool,
2056                "vsp_bsp_simulate_octree=",
2057                "false");
2058
2059        RegisterOption("VspBspTree.nodePriorityQueueType",
2060                optInt,
2061                "vsp_bsp_node_queue_type=",
2062                "0");
2063
2064        RegisterOption("VspBspTree.useRandomAxis",
2065                optBool,
2066                "-vsp_bsp_use_random_axis=",
2067                "false");
2068
2069        RegisterOption("VspBspTree.maxTotalMemory",
2070                optFloat,
2071                "vsp_bsp_max_total_mem=",
2072                "60.0");
2073
2074        RegisterOption("VspBspTree.maxStaticMemory",
2075                optFloat,
2076                "vsp_bsp_max_static_mem=",
2077                "8.0");
2078
2079       
2080       
2081
2082        //////////////////////////////////////////////////////////////////////////////////
2083}
2084
2085void
2086Environment::SetStaticOptions()
2087{
2088 
2089  // get Global option values
2090  GetRealValue("Limits.threshold", Limits::Threshold);
2091  GetRealValue("Limits.small", Limits::Small);
2092  GetRealValue("Limits.infinity", Limits::Infinity);
2093
2094
2095}
2096
2097bool
2098Environment::Parse(const int argc, char **argv, bool useExePath)
2099{
2100  bool result = true;
2101  // Read the names of the scene, environment and output files
2102  ReadCmdlineParams(argc, argv, "");
2103
2104  char *envFilename = new char[128];
2105
2106  char filename[64];
2107
2108  // Get the environment file name
2109  if (!GetParam(' ', 0, filename)) {
2110    // user didn't specified environment file explicitly, so
2111    strcpy(filename, "default.Environment::GetSingleton()");
2112  }
2113 
2114  if (useExePath) {
2115    char *path = GetPath(argv[0]);
2116    if (*path != 0)
2117      sprintf(envFilename, "%s/%s", path, filename);
2118    else
2119      strcpy(envFilename, filename);
2120   
2121    delete path;
2122  }
2123  else
2124    strcpy(envFilename, filename);
2125
2126 
2127  // Now it's time to read in environment file.
2128  if (!ReadEnvFile(envFilename)) {
2129    // error - bad input file name specified ?
2130    cerr<<"Error parsing environment file "<<envFilename<<endl;
2131        result = false;
2132  }
2133  delete envFilename;
2134
2135  // Parse the command line; options given on the command line subsume
2136  // stuff specified in the input environment file.
2137  ParseCmdline(argc, argv, 0);
2138
2139  SetStaticOptions();
2140
2141  // Check for request for help
2142  if (CheckForSwitch(argc, argv, '?')) {
2143    PrintUsage(cout);
2144    exit(0);
2145  }
2146 
2147  return true;
2148}
2149
2150}
Note: See TracBrowser for help on using the repository browser.