source: trunk/VUT/GtpVisibilityPreprocessor/src/Environment.cpp @ 473

Revision 473, 47.3 KB checked in by mattausch, 19 years ago (diff)

worked on new features,
removed Random Bug (took only 32000 values),
removed bug when choosing new candidates (totally wrong)
introduced new candidate plane method
implemented priority queue for vsp bsp
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
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,
51                             const char *argv[],
52                             const char swtch) const
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,
132                                const char *argv[],
133                                const char *optParams)
134{
135  int i;
136
137  // Make sure we are called for the first time
138  if (optionalParams != NULL)
139    return;
140
141  numParams = (int)strlen(optParams) + 1;
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
392    value = (Real)strtod(options[i].value, NULL);
393  } else {
394    // option was not read, so use the default
395    value = (Real)strtod(options[i].defaultValue, NULL);
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,
621                           const char *argv[],
622                           const int index)
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;
1045  maxOptions = 200;
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",
1066                 optString,
1067                 "-scene_filename=",
1068                 "atlanta2.x3d");
1069
1070  RegisterOption("Unigraphics.meshGrouping",
1071                 optInt,
1072                 "-unigraphics_mesh_grouping=",
1073                 "0");
1074 
1075
1076  RegisterOption("KdTree.Termination.minCost",
1077                 optInt,
1078                 "-kd_term_min_cost=",
1079                 "10");
1080 
1081  RegisterOption("KdTree.Termination.maxDepth",
1082                 optInt,
1083                 "-kd_term_max_depth=",
1084                 "20");
1085
1086  RegisterOption("KdTree.Termination.maxCostRatio",
1087                 optFloat,
1088                 "-kd_term_max_cost_ratio=",
1089                 "1.5");
1090
1091  RegisterOption("KdTree.Termination.ct_div_ci",
1092                 optFloat,
1093                 "-kd_term_ct_div_ci=",
1094                 "1.0");
1095
1096  RegisterOption("KdTree.splitMethod",
1097                 optString,
1098                 "-kd_split_method=",
1099                 "spatialMedian");
1100
1101  RegisterOption("KdTree.splitBorder",
1102                 optFloat,
1103                 "-kd_split_border=",
1104                 "0.1");
1105
1106  RegisterOption("KdTree.sahUseFaces",
1107                 optBool,
1108                 "-kd_sah_use_faces=",
1109                 "true");
1110
1111
1112  RegisterOption("MeshKdTree.Termination.minCost",
1113                 optInt,
1114                 "-kd_term_min_cost=",
1115                 "10");
1116 
1117  RegisterOption("MeshKdTree.Termination.maxDepth",
1118                 optInt,
1119                 "-kd_term_max_depth=",
1120                 "20");
1121
1122  RegisterOption("MeshKdTree.Termination.maxCostRatio",
1123                 optFloat,
1124                 "-kd_term_max_cost_ratio=",
1125                 "1.5");
1126
1127  RegisterOption("MeshKdTree.Termination.ct_div_ci",
1128                 optFloat,
1129                 "-kd_term_ct_div_ci=",
1130                 "1.0");
1131
1132  RegisterOption("MeshKdTree.splitMethod",
1133                 optString,
1134                 "-kd_split_method=",
1135                 "spatialMedian");
1136
1137  RegisterOption("MeshKdTree.splitBorder",
1138                 optFloat,
1139                 "-kd_split_border=",
1140                 "0.1");
1141
1142  RegisterOption("Sampling.totalSamples",
1143                 optInt,
1144                 "-total_samples=",
1145                 "1000000");
1146
1147  RegisterOption("Sampling.samplesPerPass",
1148                 optInt,
1149                 "-samples_per_pass=",
1150                 "10");
1151
1152  RegisterOption("VssPreprocessor.initialSamples",
1153          optInt,
1154          "-initial_samples=",
1155          "100000");
1156
1157  RegisterOption("VssPreprocessor.vssSamples",
1158          optInt,
1159          "-vss_samples=",
1160          "1000000");
1161       
1162  RegisterOption("VssPreprocessor.vssSamplesPerPass",
1163          optInt,
1164          "-vss_samples_per_pass=",
1165          "1000");
1166
1167  RegisterOption("VssPreprocessor.samplesPerPass",
1168          optInt,
1169          "-samples_per_pass=",                                                         
1170          "100000");
1171
1172
1173  RegisterOption("VssPreprocessor.useImportanceSampling",
1174          optBool,
1175          "-vss_use_importance=",
1176          "true");
1177
1178
1179  /************************************************************************************/
1180  /*                         View cells related options                               */
1181  /************************************************************************************/
1182
1183
1184  RegisterOption("ViewCells.type",
1185                 optString,
1186                 "-view_cells_type",
1187                 "bspTree");
1188
1189  RegisterOption("ViewCells.PostProcessing.samples",
1190          optInt,
1191          "-bsp_postprocessing_samples=",
1192          "200000");
1193
1194  RegisterOption("ViewCells.Visualization.samples",
1195          optInt,
1196          "-view_cells_visualization_samples=",
1197          "20000");
1198
1199   RegisterOption("ViewCells.loadFromFile",
1200                 optBool,
1201                 "-view_cells_load_from_file",
1202                 "false");
1203
1204  RegisterOption("ViewCells.maxViewCells",
1205                 optInt,
1206                 "-view_cells_max_view_cells",
1207                 "0");
1208
1209  RegisterOption("ViewCells.PostProcessing.minPvsDif",
1210                 optInt,
1211                 "-view_cells_post_processing_min_pvs_dif",
1212                 "10");
1213
1214  RegisterOption("ViewCells.PostProcessing.maxPvs",
1215                 optInt,
1216                 "-view_cells_post_processing_max_pvs",
1217                 "300");
1218
1219  RegisterOption("ViewCells.PostProcessing.minPvs",
1220                 optString,
1221                 "-view_cells_post_processing_min_pvs",
1222                 "10");
1223
1224  RegisterOption("ViewCells.filename",
1225                 optString,
1226                 "-view_cells_filename=",
1227                 "atlanta_viewcells_large.x3d");
1228
1229   RegisterOption("ViewCells.height",
1230                 optFloat,
1231                 "-view_cells_height=",
1232                 "5.0");
1233   
1234  /************************************************************************************/
1235  /*                         Render simulation related options                        */
1236  /************************************************************************************/
1237
1238
1239  RegisterOption("Simulation.objRenderCost",
1240                 optFloat,
1241                 "-simulation_obj_render_cost",
1242                 "1.0");
1243
1244  RegisterOption("Simulation.vcOverhead",
1245                 optFloat,
1246                 "-simulation_vc_overhead",
1247                 "0.05");
1248
1249  RegisterOption("Simulation.moveSpeed",
1250                 optFloat,
1251                 "-simulation_moveSpeed",
1252                 "1.0");
1253
1254
1255
1256
1257  /************************************************************************************/
1258  /*                         Bsp tree related options                                 */
1259  /************************************************************************************/
1260
1261
1262  RegisterOption("BspTree.Construction.input",
1263          optString,
1264          "-bsp_construction_input=",
1265          "fromViewCells");
1266 
1267  RegisterOption("BspTree.Construction.samples",
1268          optInt,
1269          "-bsp_construction_samples=",
1270          "100000");
1271
1272  RegisterOption("BspTree.Construction.epsilon",
1273          optFloat,
1274          "-bsp_construction_side_tolerance=",
1275          "0.002");
1276
1277  RegisterOption("BspTree.Termination.minPolygons",
1278                 optInt,
1279                 "-bsp_term_min_polygons=",
1280                 "5");
1281
1282  RegisterOption("BspTree.Termination.minPvs",
1283                 optInt,
1284                 "-bsp_term_min_pvs=",
1285                 "20");
1286
1287  RegisterOption("BspTree.Termination.minArea",
1288                 optFloat,
1289                 "-bsp_term_min_area=",
1290                 "0.001");
1291 
1292  RegisterOption("BspTree.Termination.maxRayContribution",
1293                 optFloat,
1294                 "-bsp_term_ray_contribution=",
1295                 "0.005");
1296
1297  RegisterOption("BspTree.Termination.minAccRayLenght",
1298                 optFloat,
1299                 "-bsp_term_min_acc_ray_length=",
1300                 "50");
1301
1302   RegisterOption("BspTree.Termination.minRays",
1303                 optInt,
1304                 "-bsp_term_min_rays=",
1305                 "-1");
1306
1307   RegisterOption("BspTree.Termination.ct_div_ci",
1308                 optFloat,
1309                 "-bsp_term_ct_div_ci=",
1310                 "0.0");
1311 
1312  RegisterOption("BspTree.Termination.maxDepth",
1313                 optInt,
1314                 "-bsp_term_max_depth=",
1315                 "100");
1316
1317  RegisterOption("BspTree.Termination.maxCostRatio",
1318                 optFloat,
1319                 "-bsp_term_axis_aligned_max_cost_ratio=",
1320                 "1.5");
1321
1322  RegisterOption("BspTree.Termination.AxisAligned.ct_div_ci",
1323                 optFloat,
1324                 "-bsp_term_axis_aligned_ct_div_ci=",
1325                 "0.5");
1326
1327  RegisterOption("BspTree.AxisAligned.splitBorder",
1328                 optFloat,
1329                 "-bsp__axis_aligned_split_border=",
1330                 "0.1");
1331
1332  RegisterOption("BspTree.Termination.AxisAligned.minPolys",
1333                 optInt,
1334                 "-bsp_term_axis_aligned_max_polygons=",
1335                 "50");
1336
1337   RegisterOption("BspTree.Termination.AxisAligned.minObjects",
1338                 optInt,
1339                 "-bsp_term_min_objects=",
1340                 "3");
1341
1342  RegisterOption("BspTree.Termination.AxisAligned.minRays",
1343                 optInt,
1344                 "-bsp_term_axis_aligned_min_rays=",
1345                 "-1");
1346
1347  RegisterOption("BspTree.splitPlaneStrategy",
1348                 optString,
1349                 "-bsp_split_method=",
1350                 "leastSplits");
1351
1352  RegisterOption("BspTree.maxPolyCandidates",
1353          optInt,
1354          "-bsp_max_poly_candidates=",
1355          "20");
1356
1357  RegisterOption("BspTree.maxRayCandidates",
1358          optInt,
1359          "-bsp_max_plane_candidates=",
1360          "20");
1361
1362  RegisterOption("BspTree.maxTests",
1363          optInt,
1364          "-bsp_max_tests=",
1365          "5000");
1366
1367  RegisterOption("BspTree.Visualization.exportSplits",
1368          optBool,
1369          "-bsp_visualization.export_splits",
1370          "false");
1371
1372   RegisterOption("BspTree.Visualization.exportRays",
1373          optBool,
1374          "-bsp_visualization.export_rays",
1375          "false");
1376   
1377   RegisterOption("BspTree.Visualization.exportGeometry",
1378          optBool,
1379          "-bsp_visualization.export_geometry",
1380          "false");
1381
1382   RegisterOption("BspTree.Factor.verticalSplits", optFloat, "-bsp_factor_vertical=", "1.0");
1383   RegisterOption("BspTree.Factor.largestPolyArea", optFloat, "-bsp_factor_largest_poly=", "1.0");
1384   RegisterOption("BspTree.Factor.blockedRays", optFloat, "-bsp_factor_blocked=", "1.0");
1385   RegisterOption("BspTree.Factor.leastSplits", optFloat, "-bsp_factor_least_splits=", "1.0");
1386   RegisterOption("BspTree.Factor.balancedPolys", optFloat, "-bsp_factor_balanced_polys=", "1.0");
1387   RegisterOption("BspTree.Factor.balancedViewCells", optFloat, "-bsp_factor_balanced_view_cells=", "1.0");
1388   RegisterOption("BspTree.Factor.leastRaySplits", optFloat, "-bsp_factor_least_ray_splits=", "1.0");
1389   RegisterOption("BspTree.Factor.balancedRays", optFloat, "-bsp_factor_balanced_rays=", "1.0");
1390   RegisterOption("BspTree.Factor.pvs", optFloat, "-bsp_factor_pvs=", "1.0");
1391
1392   /************************************************************************************/
1393   /*                         Preprocessor related options                             */
1394   /************************************************************************************/
1395
1396   RegisterOption("Preprocessor.type",
1397                                 optString,
1398                                 "-preprocessor=",
1399                                 "sampling");
1400
1401
1402   /**************************************************************************************/
1403   /*                  View space partition KD tree related options                      */
1404   /**************************************************************************************/
1405
1406   RegisterOption("VspKdTree.Construction.samples",
1407           optInt,
1408           "-vsp_kd_construction_samples=",
1409           "100000");
1410
1411   RegisterOption("VspKdTree.Termination.maxDepth",
1412           optInt,
1413           "vsp_term_maxdepth=", "30");
1414
1415   RegisterOption("VspKdTree.Termination.minPvs",
1416           optInt,
1417           "vsp_minpvs=",
1418           "1");
1419
1420   RegisterOption("VspKdTree.Termination.minRays",
1421           optInt,
1422           "vsp_term_minrays=",
1423           "10");
1424
1425   RegisterOption("VspKdTree.Termination.minSize",
1426           optFloat,
1427           "vsp_term_minsize=",
1428           "0.001");
1429
1430   RegisterOption("VspKdTree.Termination.maxCostRatio",
1431           optFloat,
1432           "vsp_term_maxcost=",
1433           "0.95");
1434
1435   RegisterOption("VspKdTree.Termination.maxRayContribution",
1436           optFloat,
1437           "vsp_term_max_ray_contrib=",
1438           "0.5");
1439
1440   RegisterOption("VspKdTree.epsilon",
1441           optFloat,
1442           "kd_eps=",
1443           "1e-6");
1444
1445   RegisterOption("VspKdTree.ct_div_ci",
1446           optFloat,
1447           "vsp_ctdivci=", "1.0");
1448   
1449   RegisterOption("VspKdTree.splitType",
1450           optString,
1451           "split=",
1452           "queries");
1453
1454        RegisterOption("VspKdTree.numberOfEndPointDomains",
1455                optInt,
1456                "endpoints=",
1457                "10000");
1458
1459        RegisterOption("VspKdTree.maxTotalMemory",
1460                optFloat,
1461                "vsp_max_total_mem=",
1462                "60.0");
1463
1464        RegisterOption("VspKdTree.maxStaticMemory",
1465                optFloat,
1466                "vsp_max_static_mem=",
1467                "8.0");
1468
1469        RegisterOption("VspKdTree.queryType",
1470                optString,
1471                "qtype=",
1472                "static");
1473
1474        RegisterOption("VspKdTree.queryPosWeight",
1475                optFloat,
1476                "vsp_kd_qposweight=",
1477                "0.0");
1478
1479        RegisterOption("VspKdTree.accessTimeThreshold",
1480                optInt,
1481                "vsp_kd_accesstime=",
1482                "1000");
1483
1484        RegisterOption("VspKdTree.minCollapseDepth",
1485                optInt,
1486                "vsp_kd_min_colldepth=",
1487                "4");
1488
1489        RegisterOption("VspKdTree.PostProcess.maxCostRatio",
1490                        optFloat,
1491                        "-vsp_kd_post_process_max_cost_ratio=",
1492                        "1.5");
1493
1494        RegisterOption("VspKdTree.PostProcess.minViewCells",
1495                optInt,
1496                "vsp_kd_term_post_process_min_view_cells=",
1497                "1000");
1498
1499        RegisterOption("VspKdTree.PostProcess.maxPvsSize",
1500                optInt,
1501                "vsp_kd_term_post_process_max_pvs_size=",
1502                "100");
1503       
1504        RegisterOption("VspKdTree.Visualization.exportRays",
1505                optBool,
1506                "-vsp_kd_visualization.export_rays",
1507                "false");
1508   
1509        RegisterOption("VspKdTree.Visualization.exportGeometry",
1510                optBool,
1511                "-vsp_kd_visualization.export_geometry",
1512                "false");
1513
1514        RegisterOption("VspKdTree.Termination.missTolerance",
1515                 optInt,
1516                 "-vsp_kd_term_miss_tolerance=",
1517                 "4");
1518
1519        /************************************************************************************/
1520        /*                   VSS Preprocessor cells related options                         */
1521        /************************************************************************************/
1522
1523        RegisterOption("VssTree.maxDepth", optInt, "kd_depth=", "12");
1524        RegisterOption("VssTree.minPvs", optInt, "kd_minpvs=", "1");
1525        RegisterOption("VssTree.minRays", optInt, "kd_minrays=", "10");
1526        RegisterOption("VssTree.maxCostRatio", optFloat, "maxcost=", "0.95");
1527        RegisterOption("VssTree.maxRayContribution", optFloat, "maxraycontrib=", "0.5");
1528
1529        RegisterOption("VssTree.epsilon", optFloat, "kd_eps=", "1e-6");
1530        RegisterOption("VssTree.ct_div_ci", optFloat, "kd_ctdivci=", "1.0");
1531        RegisterOption("VssTree.randomize", optBool, "randomize", "false");
1532        RegisterOption("VssTree.splitType", optString, "split=", "queries");
1533        RegisterOption("VssTree.splitUseOnlyDrivingAxis", optBool, "splitdriving=", "false");
1534        RegisterOption("VssTree.useRss", optBool, "rss=", "false");
1535        RegisterOption("VssTree.numberOfEndPointDomains", optInt, "endpoints=", "10000");
1536
1537        RegisterOption("VssTree.minSize", optFloat, "minsize=", "0.001");
1538
1539        RegisterOption("VssTree.maxTotalMemory", optFloat, "mem=", "60.0");
1540        RegisterOption("VssTree.maxStaticMemory", optFloat, "statmem=", "8.0");
1541
1542        RegisterOption("VssTree.queryType", optString, "qtype=", "static");
1543
1544        RegisterOption("VssTree.queryPosWeight", optFloat, "qposweight=", "0.0");
1545        RegisterOption("VssTree.useRefDirSplits", optBool, "refdir", "false");
1546        RegisterOption("VssTree.refDirAngle", optFloat, "refangle=", "10");
1547        RegisterOption("VssTree.refDirBoxMaxSize", optFloat, "refboxsize=", "0.1");
1548        RegisterOption("VssTree.accessTimeThreshold", optInt, "accesstime=", "1000");
1549        RegisterOption("VssTree.minCollapseDepth", optInt, "colldepth=", "4");
1550
1551        RegisterOption("VssTree.interleaveDirSplits", optBool, "interleavedirsplits", "true");
1552        RegisterOption("VssTree.dirSplitDepth", optInt, "dirsplidepth=", "10");
1553
1554
1555        RegisterOption("RssPreprocessor.initialSamples",
1556                                                                        optInt,
1557                                                                        "-initial_samples=",
1558                                                                        "100000");
1559
1560        RegisterOption("RssPreprocessor.vssSamples",
1561                                                                        optInt,
1562                                                                        "-vss_samples=",
1563                                                                        "1000000");
1564
1565        RegisterOption("RssPreprocessor.vssSamplesPerPass",
1566                                                                        optInt,
1567                                                                        "-vss_samples_per_pass=",
1568                                                                        "1000");
1569
1570                RegisterOption("RssPreprocessor.samplesPerPass",
1571                                                                        optInt,
1572                                                                        "-samples_per_pass=",
1573                                                                        "100000");
1574
1575        RegisterOption("RssPreprocessor.useImportanceSampling",
1576                                                                        optBool,
1577                                                                        "-vss_use_importance=",
1578                                                                        "true");
1579
1580        RegisterOption("RssTree.maxDepth", optInt, "kd_depth=", "12");
1581        RegisterOption("RssTree.minPvs", optInt, "kd_minpvs=", "1");
1582        RegisterOption("RssTree.minRays", optInt, "kd_minrays=", "10");
1583        RegisterOption("RssTree.maxCostRatio", optFloat, "maxcost=", "0.95");
1584        RegisterOption("RssTree.maxRayContribution", optFloat, "maxraycontrib=", "0.5");
1585
1586        RegisterOption("RssTree.epsilon", optFloat, "kd_eps=", "1e-6");
1587        RegisterOption("RssTree.ct_div_ci", optFloat, "kd_ctdivci=", "1.0");
1588        RegisterOption("RssTree.randomize", optBool, "randomize", "false");
1589        RegisterOption("RssTree.splitType", optString, "split=", "queries");
1590        RegisterOption("RssTree.splitUseOnlyDrivingAxis", optBool, "splitdriving=", "false");
1591
1592        RegisterOption("RssTree.numberOfEndPointDomains", optInt, "endpoints=", "10000");
1593
1594        RegisterOption("RssTree.minSize", optFloat, "minsize=", "0.001");
1595
1596        RegisterOption("RssTree.maxTotalMemory", optFloat, "mem=", "60.0");
1597        RegisterOption("RssTree.maxStaticMemory", optFloat, "statmem=", "8.0");
1598
1599        RegisterOption("RssTree.queryType", optString, "qtype=", "static");
1600
1601        RegisterOption("RssTree.queryPosWeight", optFloat, "qposweight=", "0.0");
1602        RegisterOption("RssTree.useRefDirSplits", optBool, "refdir", "false");
1603        RegisterOption("RssTree.refDirAngle", optFloat, "refangle=", "10");
1604        RegisterOption("RssTree.refDirBoxMaxSize", optFloat, "refboxsize=", "0.1");
1605        RegisterOption("RssTree.accessTimeThreshold", optInt, "accesstime=", "1000");
1606        RegisterOption("RssTree.minCollapseDepth", optInt, "colldepth=", "4");
1607
1608        RegisterOption("RssTree.interleaveDirSplits", optBool, "interleavedirsplits", "true");
1609        RegisterOption("RssTree.dirSplitDepth", optInt, "dirsplidepth=", "10");
1610
1611        RegisterOption("RssPreprocessor.Export.pvs", optBool, "rss_export_pvs", "false");
1612        RegisterOption("RssPreprocessor.Export.rssTree", optBool, "rss_export_rss_tree", "false");
1613        RegisterOption("RssPreprocessor.Export.rays", optBool, "rss_export_rays", "false");
1614        RegisterOption("RssPreprocessor.Export.numRays", optInt, "rss_export_num_rays=", "5000");
1615        RegisterOption("RssPreprocessor.useViewcells", optBool, "rss_use_viewcells", "false");
1616        RegisterOption("RssPreprocessor.updateSubdivision", optBool, "rss_update_subdivision", "false");
1617
1618
1619        /************************************************************************************/
1620        /*               View space partition BSP tree related options                      */
1621        /************************************************************************************/
1622
1623
1624        RegisterOption("VspBspTree.Termination.minPolygons",
1625                        optInt,
1626                        "-vsp_bsp_term_min_polygons=",
1627                        "5");
1628
1629        RegisterOption("VspBspTree.Termination.minPvs",
1630                        optInt,
1631                        "-vsp_bsp_term_min_pvs=",
1632                        "20");
1633
1634        RegisterOption("VspBspTree.Termination.minArea",
1635                        optFloat,
1636                        "-vsp_bsp_term_min_area=",
1637                        "0.001");
1638
1639        RegisterOption("VspBspTree.Termination.maxRayContribution",
1640                        optFloat,
1641                        "-vsp_bsp_term_ray_contribution=",
1642                        "0.005");
1643
1644        RegisterOption("VspBspTree.Termination.minAccRayLenght",
1645                        optFloat,
1646                        "-vsp_bsp_term_min_acc_ray_length=",
1647                        "50");
1648
1649        RegisterOption("VspBspTree.Termination.minRays",
1650                        optInt,
1651                        "-vsp_bsp_term_min_rays=",
1652                        "-1");
1653
1654        RegisterOption("VspBspTree.Termination.ct_div_ci",
1655                        optFloat,
1656                        "-vsp_bsp_term_ct_div_ci=",
1657                        "0.0");
1658
1659        RegisterOption("VspBspTree.Termination.maxDepth",
1660                        optInt,
1661                        "-vsp_bsp_term_max_depth=",
1662                        "100");
1663
1664        RegisterOption("VspBspTree.Termination.AxisAligned.maxCostRatio",
1665                        optFloat,
1666                        "-vsp_bsp_term_axis_aligned_max_cost_ratio=",
1667                        "1.5");
1668
1669        RegisterOption("VspBspTree.Termination.maxCostRatio",
1670                optFloat,
1671                "-vsp_bsp_term_max_cost_ratio=",
1672                "1.5");
1673
1674        RegisterOption("VspBspTree.Termination.missTolerance",
1675                 optInt,
1676                 "-vsp_bsp_term_miss_tolerance=",
1677                 "4");
1678
1679        RegisterOption("VspBspTree.Termination.AxisAligned.ct_div_ci",
1680                        optFloat,
1681                        "-vsp_bsp_term_axis_aligned_ct_div_ci=",
1682                        "0.5");
1683
1684        RegisterOption("VspBspTree.AxisAligned.splitBorder",
1685                        optFloat,
1686                        "-vsp_bsp__axis_aligned_split_border=",
1687                        "0.1");
1688
1689        RegisterOption("VspBspTree.Termination.AxisAligned.minPolys",
1690                        optInt,
1691                        "-vsp_bsp_term_axis_aligned_max_polygons=",
1692                        "50");
1693
1694        RegisterOption("VspBspTree.Termination.AxisAligned.minObjects",
1695                        optInt,
1696                        "-vsp_bsp_term_min_objects=",
1697                        "3");
1698
1699        RegisterOption("VspBspTree.Termination.AxisAligned.minRays",
1700                        optInt,
1701                        "-vsp_bsp_term_axis_aligned_min_rays=",
1702                        "-1");
1703
1704        RegisterOption("VspBspTree.splitPlaneStrategy",
1705                        optString,
1706                        "-vsp_bsp_split_method=",
1707                        "leastSplits");
1708
1709        RegisterOption("VspBspTree.maxPolyCandidates",
1710                optInt,
1711                "-vsp_bsp_max_poly_candidates=",
1712                "20");
1713
1714        RegisterOption("VspBspTree.maxRayCandidates",
1715                optInt,
1716                "-vsp_bsp_max_plane_candidates=",
1717                "20");
1718
1719        RegisterOption("VspBspTree.maxTests",
1720                optInt,
1721                "-vsp_bsp_max_tests=",
1722                "5000");
1723
1724        RegisterOption("VspBspTree.Construction.samples",
1725                optInt,
1726                "-bsp_construction_samples=",
1727                "100000");
1728
1729        RegisterOption("VspBspTree.Construction.epsilon",
1730                optFloat,
1731                "-vsp_bsp_construction_side_tolerance=",
1732                "0.002");
1733
1734        RegisterOption("VspBspTree.Visualization.exportSplits",
1735                optBool,
1736                "-vsp_bsp_visualization.export_splits",
1737                "false");
1738        RegisterOption("VspBspTree.Visualization.exportRays",
1739                optBool,
1740                "-vsp_bsp_visualization.export_rays",
1741                "false");
1742   
1743        RegisterOption("VspBspTree.Visualization.exportGeometry",
1744                optBool,
1745                "-vsp_bsp_visualization.export_geometry",
1746                "false");
1747
1748        RegisterOption("VspBspTree.Factor.leastRaySplits", optFloat, "-vsp_bsp_factor_least_ray_splits=", "1.0");
1749        RegisterOption("VspBspTree.Factor.balancedRays", optFloat, "-vsp_bsp_factor_balanced_rays=", "1.0");
1750        RegisterOption("VspBspTree.Factor.pvs", optFloat, "-vsp_bsp_factor_pvs=", "1.0");
1751
1752        //////////////////////////////////////////////////////////////////////////////////
1753}
1754
1755void
1756Environment::SetStaticOptions()
1757{
1758 
1759  // get Global option values
1760  GetRealValue("Limits.threshold", Limits::Threshold);
1761  GetRealValue("Limits.small", Limits::Small);
1762  GetRealValue("Limits.infinity", Limits::Infinity);
1763
1764
1765}
1766
1767void
1768Environment::Parse(const int argc, const char *argv[], bool useExePath)
1769{
1770 
1771  // Read the names of the scene, environment and output files
1772  ReadCmdlineParams(argc, argv, "");
1773
1774  char *envFilename = new char[128];
1775
1776  char filename[64];
1777
1778  // Get the environment file name
1779  if (!GetParam(' ', 0, filename)) {
1780    // user didn't specified environment file explicitly, so
1781    strcpy(filename, "default.env");
1782  }
1783 
1784  if (useExePath) {
1785    char *path = GetPath(argv[0]);
1786    if (*path != 0)
1787      sprintf(envFilename, "%s/%s", path, filename);
1788    else
1789      strcpy(envFilename, filename);
1790   
1791    delete path;
1792  }
1793  else
1794    strcpy(envFilename, filename);
1795
1796 
1797  // Now it's time to read in environment file.
1798  if (!ReadEnvFile(envFilename)) {
1799    // error - bad input file name specified ?
1800    cerr<<"Error parsing environment file "<<envFilename<<endl;
1801  }
1802  delete envFilename;
1803
1804  // Parse the command line; options given on the command line subsume
1805  // stuff specified in the input environment file.
1806  ParseCmdline(argc, argv, 0);
1807
1808  SetStaticOptions();
1809
1810  // Check for request for help
1811  if (CheckForSwitch(argc, argv, '?')) {
1812    PrintUsage(cout);
1813    exit(0);
1814  }
1815
1816}
Note: See TracBrowser for help on using the repository browser.