Ignore:
Timestamp:
02/08/06 20:32:42 (19 years ago)
Author:
bittner
Message:

slider support for viewcells

Location:
trunk/VUT/GtpVisibilityPreprocessor/src
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/GtpVisibilityPreprocessor/src/GlRenderer.cpp

    r599 r608  
    1313#include <Cg/cgGL.h> 
    1414 
     15#include <QVBoxLayout> 
     16 
    1517static CGcontext sCgContext = NULL; 
    1618static CGprogram sCgFragmentProgram = NULL; 
    … …  
    4345  mViewPoint = mSceneGraph->GetBox().Center(); 
    4446  mViewDirection = Vector3(0,0,1); 
     47 
    4548  //  timerId = startTimer(10); 
    4649  // debug coords for atlanta 
    47   mViewPoint = Vector3(3473, 6.778, -1699); 
    48   mViewDirection = Vector3(-0.2432, 0, 0.97); 
     50  //  mViewPoint = Vector3(3473, 6.778, -1699); 
     51  //  mViewDirection = Vector3(-0.2432, 0, 0.97); 
    4952   
    5053  mFrame = 0; 
    … …  
    205208{ 
    206209  QString s; 
    207   s.sprintf("frame:%04d viewpoint:(%4.1f,%4.1f,%4.1f) dir:(%4.1f,%4.1f,%4.1f)", 
     210  int vc = 0; 
     211  if (mViewCellsManager) 
     212        vc = mViewCellsManager->GetViewCells().size(); 
     213  s.sprintf("frame:%04d viewpoint:(%4.1f,%4.1f,%4.1f) dir:(%4.1f,%4.1f,%4.1f) viewcells:%04d", 
    208214                        mFrame, 
    209215                        mViewPoint.x, 
    … …  
    212218                        mViewDirection.x, 
    213219                        mViewDirection.y, 
    214                         mViewDirection.z 
    215  
     220                        mViewDirection.z, 
     221                        vc 
    216222                        ); 
    217223  renderText(0,20,s); 
    … …  
    433439 
    434440 
     441void 
     442GlRendererWidget::SetupProjection(const int w, const int h) 
     443{ 
     444  if (!mTopView) 
     445        GlRenderer::SetupProjection(w, h); 
     446  else { 
     447        glViewport(0, 0, w, h); 
     448        glMatrixMode(GL_PROJECTION); 
     449        glLoadIdentity(); 
     450        gluPerspective(50.0, 1.0, 0.1, 20.0*Magnitude(mSceneGraph->GetBox().Diagonal())); 
     451        glMatrixMode(GL_MODELVIEW); 
     452  } 
     453} 
     454 
    435455float 
    436456GlRendererWidget::RenderErrors() 
    … …  
    444464  SetupCamera(); 
    445465  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    446  
    447  
     466   
     467  double eq[4]; 
     468  eq[0] = mSceneCutPlane.mNormal.x; 
     469  eq[1] = mSceneCutPlane.mNormal.y; 
     470  eq[2] = mSceneCutPlane.mNormal.z; 
     471  eq[3] = mSceneCutPlane.mD; 
     472   
     473  if (mCutScene) { 
     474        glClipPlane(GL_CLIP_PLANE0, eq); 
     475    glEnable(GL_CLIP_PLANE0); 
     476  } 
     477   
    448478  if (mDetectEmptyViewSpace)  
    449479        glEnable( GL_CULL_FACE ); 
    … …  
    553583  } 
    554584 
     585  glDisable(GL_CLIP_PLANE0); 
     586 
    555587  return pErrorPixels; 
    556588} 
    … …  
    697729GlRendererWidget::paintGL() 
    698730{ 
    699   if (mRenderViewCells) 
     731  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
     732 
     733   
     734  RenderErrors(); 
     735  RenderInfo(); 
     736 
     737    if (mRenderViewCells)  
    700738        RenderViewCells(); 
    701   else { 
    702         RenderErrors(); 
    703         RenderInfo(); 
    704   } 
    705    
     739 
    706740  mFrame++; 
    707741} 
    … …  
    714748        GlRenderer::SetupCamera(); 
    715749  else { 
    716         float dist = Magnitude(mSceneGraph->GetBox().Diagonal())*0.05; 
    717         Vector3 pos = mViewPoint - dist*Vector3(mViewDirection.x, 
    718                                                                                         -1, 
    719                                                                                         mViewDirection.y); 
    720          
    721         Vector3 target = mViewPoint + dist*mViewDirection; 
    722         Vector3 up(0,1,0); 
    723          
    724         glLoadIdentity(); 
    725         gluLookAt(pos.x, pos.y, pos.z, 
    726                           target.x, target.y, target.z, 
    727                           up.x, up.y, up.z); 
     750        if (0) { 
     751          float dist = Magnitude(mSceneGraph->GetBox().Diagonal())*0.05; 
     752          Vector3 pos = mViewPoint - dist*Vector3(mViewDirection.x, 
     753                                                                                          -1, 
     754                                                                                          mViewDirection.y); 
     755           
     756          Vector3 target = mViewPoint + dist*mViewDirection; 
     757          Vector3 up(0,1,0); 
     758           
     759          glLoadIdentity(); 
     760          gluLookAt(pos.x, pos.y, pos.z, 
     761                                target.x, target.y, target.z, 
     762                                up.x, up.y, up.z); 
     763        } else { 
     764          float dist = Magnitude(mSceneGraph->GetBox().Diagonal())*mTopDistance; 
     765          Vector3 pos = mViewPoint  + dist*Vector3(0, 
     766                                                                                           1, 
     767                                                                                           0); 
     768           
     769          Vector3 target = mViewPoint; 
     770          Vector3 up(mViewDirection.x, 0, mViewDirection.z); 
     771           
     772          glLoadIdentity(); 
     773          gluLookAt(pos.x, pos.y, pos.z, 
     774                                target.x, target.y, target.z, 
     775                                up.x, up.y, up.z); 
     776           
     777        } 
    728778  } 
    729779 
    … …  
    736786  case Qt::Key_T: 
    737787        mTopView = !mTopView; 
     788        SetupProjection(width(), height()); 
    738789        updateGL(); 
    739790        break; 
    … …  
    746797        break; 
    747798  } 
    748    
     799} 
     800 
     801   
     802RendererControlWidget::RendererControlWidget(QWidget * parent, Qt::WFlags f): 
     803  QWidget(parent, f) 
     804{ 
     805 
     806  QVBoxLayout *vl = new QVBoxLayout; 
     807  setLayout(vl); 
     808   
     809  QWidget *vbox = new QGroupBox("ViewCells", this); 
     810  layout()->addWidget(vbox); 
     811   
     812  vl = new QVBoxLayout; 
     813  vbox->setLayout(vl); 
     814   
     815  QSlider *slider = new QSlider(Qt::Horizontal, vbox); 
     816  vl->addWidget(slider); 
     817  slider->show(); 
     818  slider->setRange(1, 10000); 
     819  slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred); 
     820  slider->setValue(500); 
     821 
     822  connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetViewCellGranularity(int))); 
     823 
     824 
     825 
     826  QWidget *hbox = new QWidget(vbox); 
     827  vl->addWidget(hbox); 
     828  QHBoxLayout *hlayout = new QHBoxLayout; 
     829  hbox->setLayout(hlayout); 
     830   
     831  QCheckBox *cb = new QCheckBox("Show viewcells", hbox); 
     832  hlayout->addWidget(cb); 
     833  cb->setChecked(false); 
     834  connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetShowViewCells(bool))); 
     835 
     836  vbox->resize(800,100); 
     837 
     838   
     839  vbox = new QGroupBox("Rendering", this); 
     840  layout()->addWidget(vbox); 
     841   
     842  vl = new QVBoxLayout; 
     843  vbox->setLayout(vl); 
     844   
     845  slider = new QSlider(Qt::Horizontal, vbox); 
     846  vbox->layout()->addWidget(slider); 
     847  slider->show(); 
     848  slider->setRange(0, 1000); 
     849  slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred); 
     850  slider->setValue(1000); 
     851 
     852  connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetSceneCut(int))); 
     853 
     854 
     855  cb = new QCheckBox("Cut view cells", vbox); 
     856  vbox->layout()->addWidget(cb); 
     857  cb->setChecked(false); 
     858  connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetCutViewCells(bool))); 
     859 
     860  cb = new QCheckBox("Cut scene", vbox); 
     861  vbox->layout()->addWidget(cb); 
     862  cb->setChecked(false); 
     863  connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetCutScene(bool))); 
     864 
     865   
     866  slider = new QSlider(Qt::Horizontal, vbox); 
     867  vbox->layout()->addWidget(slider); 
     868  slider->show(); 
     869  slider->setRange(1, 1000); 
     870  slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred); 
     871  slider->setValue(500); 
     872   
     873  connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetTopDistance(int))); 
     874 
     875  cb = new QCheckBox("Top View", vbox); 
     876  vbox->layout()->addWidget(cb); 
     877  cb->setChecked(false); 
     878  connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetTopView(bool))); 
     879   
     880 
     881  adjustSize(); 
    749882} 
    750883 
    … …  
    761894  mTopView = false; 
    762895  mRenderViewCells = false; 
    763  
    764   QSlider *slider = new QSlider(this); 
    765   slider->show(); 
    766   slider->setRange(1, 10000); 
    767  
    768   connect(slider, SIGNAL(valueChanged(int)), this, SLOT(SetViewcellGranularity(int))); 
    769 } 
    770  
    771 void 
    772 GlRendererWidget::SetViewcellGranularity(int number) 
     896  mTopDistance = 1.0f; 
     897  mCutViewCells = false; 
     898  mCutScene = false; 
     899   
     900  RendererControlWidget *cw = new RendererControlWidget(NULL); 
     901  connect(cw, SIGNAL(SetViewCellGranularity(int)), this, SLOT(SetViewCellGranularity(int))); 
     902  connect(cw, SIGNAL(SetSceneCut(int)), this, SLOT(SetSceneCut(int))); 
     903  connect(cw, SIGNAL(SetTopDistance(int)), this, SLOT(SetTopDistance(int))); 
     904  connect(cw, SIGNAL(SetShowViewCells(bool)), this, SLOT(SetShowViewCells(bool))); 
     905  connect(cw, SIGNAL(SetTopView(bool)), this, SLOT(SetTopView(bool))); 
     906  connect(cw, SIGNAL(SetCutViewCells(bool)), this, SLOT(SetCutViewCells(bool))); 
     907  connect(cw, SIGNAL(SetCutScene(bool)), this, SLOT(SetCutScene(bool))); 
     908   
     909  cw->show(); 
     910} 
     911 
     912void 
     913GlRendererWidget::SetViewCellGranularity(int number) 
    773914{ 
    774915  mViewCellsManager->CollectViewCells(number); 
    … …  
    777918 
    778919void 
     920GlRendererWidget::SetSceneCut(int number) 
     921{ 
     922  // assume the cut plane can only be aligned with xz plane 
     923  // shift it along y according to number, which is percentage of the bounding 
     924  // box position 
     925  if (mViewCellsManager) { 
     926        AxisAlignedBox3 box = mViewCellsManager->GetViewSpaceBox(); 
     927        Vector3 p = box.Min() + (number/1000.0f)*box.Max(); 
     928        mSceneCutPlane.mNormal = Vector3(0,-1,0); 
     929        mSceneCutPlane.mD = -DotProd(mSceneCutPlane.mNormal, p); 
     930        updateGL(); 
     931  } 
     932} 
     933 
     934void 
     935GlRendererWidget::SetTopDistance(int number) 
     936{ 
     937  mTopDistance = number/1000.0f; 
     938  updateGL(); 
     939} 
     940 
     941void 
    779942GlRendererWidget::RenderViewCells() 
    780943{ 
    … …  
    782945 
    783946  SetupCamera(); 
    784   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    785  
     947  glEnable(GL_CULL_FACE); 
     948  glCullFace(GL_FRONT); 
     949  double eq[4]; 
     950  eq[0] = mSceneCutPlane.mNormal.x; 
     951  eq[1] = mSceneCutPlane.mNormal.y; 
     952  eq[2] = mSceneCutPlane.mNormal.z; 
     953  eq[3] = mSceneCutPlane.mD; 
     954 
     955  if (mCutViewCells) { 
     956        glClipPlane(GL_CLIP_PLANE0, eq); 
     957        glEnable(GL_CLIP_PLANE0); 
     958  } 
     959   
    786960  int i; 
    787961  ViewCellContainer &viewcells = mViewCellsManager->GetViewCells(); 
    788962  for (i=0; i < viewcells.size(); i++) { 
    789963        ViewCell *vc = viewcells[i]; 
    790         Mesh *m = vc->GetMesh(); 
    791         float r = RandomValue(0.5, 1.0); 
    792         float g = RandomValue(0.5, 1.0); 
    793         float b = RandomValue(0.5, 1.0); 
    794  
    795         glColor3f(r, g, b); 
    796         //SetupMaterial(m->mMaterial); 
    797  
     964        //      Mesh *m = vc->GetMesh(); 
     965        RgbColor c = vc->GetColor(); 
     966        glColor3f(c.r, c.g, c.b); 
    798967        RenderViewCell(vc); 
    799968  } 
     969 
     970  glDisable(GL_CLIP_PLANE0); 
    800971 
    801972} 

  • trunk/VUT/GtpVisibilityPreprocessor/src/GlRenderer.h

    r599 r608  
    9999 
    100100 
    101   void 
     101  virtual void 
    102102  SetupProjection(const int w, const int h); 
    103103 
    … …  
    179179 
    180180 
     181class RendererControlWidget : public QWidget 
     182{ 
     183  Q_OBJECT 
     184public: 
     185  RendererControlWidget(QWidget * parent = 0, Qt::WFlags f = 0); 
     186 
     187  signals: 
     188   
     189  SetViewCellGranularity(int); 
     190  SetSceneCut(int); 
     191  SetTopDistance(int); 
     192 
     193  SetShowViewCells(bool); 
     194  SetTopView(bool); 
     195  SetCutViewCells(bool); 
     196  SetCutScene(bool); 
     197 
     198}; 
    181199 
    182200class GlRendererWidget : public QGLWidget, public GlRenderer 
    … …  
    190208  bool mTopView; 
    191209  bool mRenderViewCells; 
     210  bool mCutViewCells; 
     211  bool mCutScene; 
     212   
     213  Plane3 mSceneCutPlane; 
     214  float mTopDistance; 
    192215   
    193216  GlRendererWidget(SceneGraph *sceneGraph, 
    … …  
    223246  virtual int GetHeight() const { return height(); } 
    224247 
     248  virtual void 
     249  SetupProjection(const int w, const int h); 
    225250 
    226251  void 
    … …  
    229254 public slots: 
    230255 void 
    231  SetViewcellGranularity(int number); 
    232  
     256 SetViewCellGranularity(int number); 
     257 
     258 void 
     259 SetSceneCut(int cut); 
     260 
     261 void 
     262 SetTopDistance(int dist); 
     263 
     264  void SetShowViewCells(bool b) { 
     265        mRenderViewCells = b; 
     266        updateGL(); 
     267  } 
     268   
     269  void SetTopView(bool b) { 
     270        mTopView = b; 
     271        updateGL(); 
     272  } 
     273 
     274  void SetCutViewCells(bool b) { 
     275        mCutViewCells = b; 
     276        updateGL(); 
     277  } 
     278  void SetCutScene(bool b) { 
     279        mCutScene = b; 
     280        updateGL(); 
     281  } 
    233282 
    234283}; 
    … …  
    253302    void initPbuffer(); 
    254303 
     304   
    255305         GlRendererBuffer *mRenderBuffer; 
    256306 
    … …  
    258308         int mSamples; 
    259309         Intersectable *mSourceObject; 
     310 
    260311private: 
    261312    GLuint dynamicTexture; 

  • trunk/VUT/GtpVisibilityPreprocessor/src/Material.cpp

    r162 r608  
    1010 
    1111  Material m; 
    12   m.mDiffuseColor = 
    13     RgbColor(a + Random(b), 
    14              a + Random(b), 
    15              a + Random(b)); 
     12  m.mDiffuseColor = RandomColor(a, b); 
    1613 
    1714  return m; 
    1815} 
    1916 
     17 
     18RgbColor 
     19RandomColor(const float a, const float b) 
     20{ 
     21  return RgbColor(a + Random(b), 
     22                                  a + Random(b), 
     23                                  a + Random(b)); 
     24} 

  • trunk/VUT/GtpVisibilityPreprocessor/src/Material.h

    r386 r608  
    1818  { 
    1919  } 
    20    
     20 
     21  friend RgbColor 
     22  RandomColor(const float a=0.0f, const float b=1.0f); 
     23 
    2124}; 
    2225 
    … …  
    3235  { 
    3336  } 
    34  
    35         Material(const RgbColor &color):mDiffuseColor(color), 
    36                                                                                                                                         mAmbientColor(color), 
    37                                                                                                                                         mSpecularColor(0,0,0) 
    38         { 
    39         } 
    40  
     37   
     38  Material(const RgbColor &color):mDiffuseColor(color), 
     39                                                                  mAmbientColor(color), 
     40                                                                  mSpecularColor(0,0,0) 
     41  { 
     42  } 
     43   
    4144  friend Material RandomMaterial(); 
    4245   

  • trunk/VUT/GtpVisibilityPreprocessor/src/RssPreprocessor.cpp

    r587 r608  
    298298  exporter->SetFilled(); 
    299299  // $$JB temporarily do not export the scene 
    300   if (0) 
     300  if (1) 
    301301        exporter->ExportScene(mSceneGraph->mRoot); 
    302302  exporter->SetWireframe(); 

  • trunk/VUT/GtpVisibilityPreprocessor/src/ViewCell.cpp

    r607 r608  
    606606                        if (mViewCellsManager->EqualToSpatialNode(mergedVc)) 
    607607                                ++ mergeStats.siblings; 
     608                        mergedVc->SetCost(realExpectedCost); 
    608609 
    609610                        if (((mergeStats.merged % statsOut) == 0) ||  
    … …  
    664665                ViewCellInterior *root = mViewCellsManager->MergeViewCells(activeViewCells); 
    665666                root->SetMergeCost(totalRenderCost); 
     667                // $$JB keep this 0 temporarilly 
     668                root->SetCost(0.0f); 
     669                 
    666670                mRoot = root; 
    667671        } 
    … …  
    693697        Debug << mergeStats << endl << endl; 
    694698 
    695  
     699        // assign colors for the view cells so that at least one is always consistent 
     700        AssignRandomColors(); 
    696701        //TODO: should return sample contributions? 
    697702        return mergeStats.merged; 
    … …  
    15331538 
    15341539 
     1540void 
     1541ViewCellsTree::AssignRandomColors() 
     1542{ 
     1543  TraversalQueue tqueue; 
     1544  tqueue.push(mRoot); 
     1545  mRoot->SetColor(RandomColor(0.3f, 1.0f)); 
     1546  while (!tqueue.empty()) 
     1547        { 
     1548          ViewCell *vc = tqueue.top(); 
     1549           
     1550          // save the view cells if it is a leaf or if enough view cells have already been traversed 
     1551          // because of the priority queue, this will be the optimal set of v 
     1552          if (!vc->IsLeaf()) {   
     1553                ViewCellInterior *interior = dynamic_cast<ViewCellInterior *>(vc); 
     1554                 
     1555                ViewCellContainer::const_iterator it, it_end = interior->mChildren.end(); 
     1556                float maxProbability = -1.0f; 
     1557                ViewCell *maxViewCell = NULL; 
     1558                for (it = interior->mChildren.begin(); it != it_end; ++ it) { 
     1559                  ViewCell *v = *it; 
     1560                  // set random color 
     1561                  v->SetColor(RandomColor(0.3f, 1.0f)); 
     1562                  if (v->GetVolume() > maxProbability) { 
     1563                        maxProbability = v->GetVolume(); 
     1564                        maxViewCell = v; 
     1565                  } 
     1566                  maxViewCell->SetColor(vc->GetColor()); 
     1567                  tqueue.push(v); 
     1568                } 
     1569                 
     1570          } 
     1571           
     1572          tqueue.pop(); 
     1573        } 
     1574} 
     1575 
     1576/** Get costs resulting from each merge step. */ 
     1577void 
     1578ViewCellsTree::GetCostFunction(vector<float> &costFunction) 
     1579{ 
     1580  TraversalQueue tqueue; 
     1581  tqueue.push(mRoot); 
     1582  while (!tqueue.empty()) { 
     1583        ViewCell *vc = tqueue.top(); 
     1584         
     1585        // save the view cells if it is a leaf or if enough view cells have already been traversed 
     1586        // because of the priority queue, this will be the optimal set of v 
     1587        if (!vc->IsLeaf()) {     
     1588          ViewCellInterior *interior = dynamic_cast<ViewCellInterior *>(vc); 
     1589          costFunction.push_back(interior->GetCost()); 
     1590           
     1591          ViewCellContainer::const_iterator it, it_end = interior->mChildren.end(); 
     1592           
     1593          for (it = interior->mChildren.begin(); it != it_end; ++ it) { 
     1594                tqueue.push(*it); 
     1595          } 
     1596           
     1597        } 
     1598         
     1599        tqueue.pop(); 
     1600  } 
     1601} 
     1602 
     1603 
    15351604void  ViewCellsTree::UpdateViewCellsStats(ViewCell *vc, ViewCellsStatistics &vcStat) 
    15361605{ 

  • trunk/VUT/GtpVisibilityPreprocessor/src/ViewCell.h

    r605 r608  
    66#include "Ray.h" 
    77#include "Statistics.h" 
     8#include "Material.h" 
    89//namespace GtpVisibilityPreprocessor { 
    910 
    … …  
    107108        int Type() const; 
    108109 
    109         void SetParent(ViewCellInterior *parent); 
     110  void SetParent(ViewCellInterior *parent); 
    110111 
    111112        /** Adds a passing ray to the passing ray container. 
    … …  
    147148 
    148149 
    149  
    150  
     150  /** set color for visiualizations */ 
     151  void SetColor(const RgbColor &color) { 
     152        mColor = color; 
     153  } 
     154 
     155  /** get color for visualuzations */ 
     156  RgbColor GetColor() const { 
     157        return mColor; 
     158  } 
     159 
     160   
    151161        /// parent view cell in the view cell hierarchy 
    152162        ViewCellInterior *mParent; 
    … …  
    201211 
    202212        bool mValid; 
     213 
     214  /** color used for consistent visualization */ 
     215  RgbColor mColor; 
    203216}; 
    204217 
    … …  
    221234        ViewCellContainer mChildren; 
    222235 
     236  void SetCost(const float c) { 
     237        mCost = c; 
     238  } 
     239  float GetCost() const { 
     240        return mCost; 
     241  } 
     242   
     243protected: 
     244  /** overall cost resulting from the merge */ 
     245  float mCost; 
    223246}; 
    224247 
    … …  
    279302        int RefineViewCells(const VssRayContainer &rays, const ObjectContainer &objects); 
    280303 
     304  /** Assign colors to the viewcells so that they can be renderered interactively without 
     305          color flickering. 
     306  */ 
     307  void AssignRandomColors(); 
    281308        /** Updates view cell stats for this particular view cell 
    282309        */ 
    283310        void UpdateViewCellsStats(ViewCell *vc, ViewCellsStatistics &vcStat); 
    284311         
     312 
     313  /** Get costs resulting from each merge step. */ 
     314  void GetCostFunction(vector<float> &costFunction); 
     315   
    285316 
    286317        /** Returns optimal set of view cells for a given number of view cells. 

  • trunk/VUT/GtpVisibilityPreprocessor/src/default.env

    r599 r608  
    2525#       type vss 
    2626        type rss 
    27         detectEmptyViewSpace false 
     27        detectEmptyViewSpace true 
    2828        pvsRenderErrorSamples 10000 
    2929        quitOnFinish false 
    … …  
    7272 
    7373RssPreprocessor { 
    74         samplesPerPass 500000 
     74        samplesPerPass 500 
    7575        initialSamples 100 
    7676        vssSamples 100 
    77         vssSamplesPerPass 1000000 
     77        vssSamplesPerPass 100 
    7878        useImportanceSampling true 
    7979 
    … …  
    219219                exportRays true 
    220220                exportGeometry true 
    221                 exportMergedViewCells true 
    222                 useCuttingPlane true 
     221                exportMergedViewCells false 
     222                useCuttingPlane false 
    223223                cuttingPlaneAxis 1 
    224224        } 
    … …  
    283283VspBspTree { 
    284284        Construction { 
    285                 samples 300000 
     285                samples 1000000 
    286286                epsilon 0.005 
    287287                randomize false 
    … …  
    330330 
    331331                 
    332                 maxViewCells            10000 
     332                maxViewCells            50000 
    333333                 
    334334                # used for pvs criterium 
Note: See TracChangeset for help on using the changeset viewer.