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

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