source: trunk/VUT/GtpVisibilityPreprocessor/src/RssPreprocessor.cpp @ 556

#include "SceneGraph.h"
#include "KdTree.h"
#include "RssPreprocessor.h"
#include "X3dExporter.h"
#include "Environment.h"
#include "MutualVisibility.h"
#include "Polygon3.h"
#include "ViewCell.h"
#include "VssRay.h"
#include "RssTree.h"
#include "ViewCellsManager.h"
#include "RenderSimulator.h"
#include "GlRenderer.h"

static bool useViewSpaceBox = false;
static bool use2dSampling = false;


// not supported anymore!
static bool fromBoxVisibility = false;


RssPreprocessor::RssPreprocessor():
  mPass(0),
  mVssRays()
{
  // this should increase coherence of the samples
  environment->GetIntValue("RssPreprocessor.samplesPerPass", mSamplesPerPass);
  environment->GetIntValue("RssPreprocessor.initialSamples", mInitialSamples);
  environment->GetIntValue("RssPreprocessor.vssSamples", mRssSamples);
  environment->GetIntValue("RssPreprocessor.vssSamplesPerPass", mRssSamplesPerPass);
  environment->GetBoolValue("RssPreprocessor.useImportanceSampling", mUseImportanceSampling);

  environment->GetBoolValue("RssPreprocessor.Export.pvs", mExportPvs);
  environment->GetBoolValue("RssPreprocessor.Export.rssTree", mExportRssTree);
  environment->GetBoolValue("RssPreprocessor.Export.rays", mExportRays);
  environment->GetIntValue("RssPreprocessor.Export.numRays", mExportNumRays);
  environment->GetBoolValue("RssPreprocessor.useViewcells", mUseViewcells);
  environment->GetBoolValue("RssPreprocessor.objectBasedSampling", mObjectBasedSampling);
  environment->GetBoolValue("RssPreprocessor.directionalSampling", mDirectionalSampling);

  environment->GetBoolValue("RssPreprocessor.loadInitialSamples", mLoadInitialSamples);
  environment->GetBoolValue("RssPreprocessor.storeInitialSamples", mStoreInitialSamples);
  
  mStats.open("stats.log");

}

RssPreprocessor::~RssPreprocessor()
{
  // mVssRays get deleted in the tree
  //  CLEAR_CONTAINER(mVssRays);
}

void
RssPreprocessor::SetupRay(Ray &ray, 
                                                  const Vector3 &point, 
                                                  const Vector3 &direction
                                                  )
{
  ray.intersections.clear();
  // do not store anything else then intersections at the ray
  ray.Init(point, direction, Ray::LOCAL_RAY);
}

int
RssPreprocessor::CastRay(
                                                 Vector3 &viewPoint,
                                                 Vector3 &direction,
                                                 const float probability,
                                                 VssRayContainer &vssRays
                                                 )
{
  int hits = 0;
  static Ray ray;
  AxisAlignedBox3 box = mKdTree->GetBox();

  AxisAlignedBox3 sbox = box;
  sbox.Enlarge(Vector3(-Limits::Small));
  if (!sbox.IsInside(viewPoint))
        return 0;
        
  SetupRay(ray, viewPoint, direction);

  if (!mDetectEmptyViewSpace)
        ray.mFlags &= ~Ray::CULL_BACKFACES;
  else
        ray.mFlags |= Ray::CULL_BACKFACES;


  // cast ray to KD tree to find intersection with other objects
  Intersectable *objectA, *objectB;
  Vector3 pointA, pointB;
  float bsize = Magnitude(box.Size());

  
  if (mKdTree->CastRay(ray)) {
        objectA = ray.intersections[0].mObject;
        pointA = ray.Extrap(ray.intersections[0].mT);
  } else {
        objectA = NULL;
        // compute intersection with the scene bounding box
        float tmin, tmax;
        if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
          pointA = ray.Extrap(tmax);
        else
          return 0;
  }


  if (mDetectEmptyViewSpace) {
        SetupRay(ray, pointA, -direction);
  } else
        SetupRay(ray, viewPoint, -direction);
        
  if (!mDetectEmptyViewSpace)
        ray.mFlags &= ~Ray::CULL_BACKFACES;
  else
        ray.mFlags |= Ray::CULL_BACKFACES;

  if (mKdTree->CastRay(ray)) {
        objectB = ray.intersections[0].mObject;
        pointB = ray.Extrap(ray.intersections[0].mT);
  } else {
        objectB = NULL;
        float tmin, tmax;
        if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
          pointB = ray.Extrap(tmax);
        else
          return 0;
  }

  //  if (objectA == NULL && objectB != NULL) {
  if (mDetectEmptyViewSpace) {
        // cast again to ensure that there is no objectA
        SetupRay(ray, pointB, direction);
        ray.mFlags |= Ray::CULL_BACKFACES;
        if (mKdTree->CastRay(ray)) {
          objectA = ray.intersections[0].mObject;
          pointA = ray.Extrap(ray.intersections[0].mT);
        }
  }
  
  
  VssRay *vssRay  = NULL;

  bool validSample = (objectA != objectB);
  if (validSample) {
        if (objectA) {
          vssRay = new VssRay(pointB,
                                                  pointA,
                                                  objectB,
                                                  objectA,
                                                  mPass,
                                                  probability
                                                  );
          vssRays.push_back(vssRay);
          hits ++;
        }
        
        if (objectB) {
          vssRay = new VssRay(pointA,
                                                  pointB,
                                                  objectA,
                                                  objectB,
                                                  mPass,
                                                  probability
                                                  );
          vssRays.push_back(vssRay);
          hits ++;
        }
  }
        
  return hits;
}


Vector3
RssPreprocessor::GetViewpoint(AxisAlignedBox3 *viewSpaceBox)
{
  AxisAlignedBox3 box;
        
  if (viewSpaceBox)
        box =*viewSpaceBox;
  else 
        box = mKdTree->GetBox();
        
  // shrink the box in the y direction
  return box.GetRandomPoint();
}

Vector3
RssPreprocessor::GetDirection(const Vector3 &viewpoint,
                                                          AxisAlignedBox3 *viewSpaceBox
                                                          )
{
  Vector3 point;
  if (!use2dSampling) {
        if (mObjectBasedSampling) {
          Vector3 normal;
          int i = RandomValue(0, mObjects.size()-1);
          Intersectable *object = mObjects[i];
          object->GetRandomSurfacePoint(point, normal);
        } else {
          // select
          if (mDirectionalSampling) {
                point = viewpoint + UniformRandomVector();
          } else {
                // select the other point uniformly distruted in the whole viewspace
                AxisAlignedBox3 box;
                
                if (viewSpaceBox)
                  box =*viewSpaceBox;
                else 
                  box = mKdTree->GetBox();
                
                point = box.GetRandomPoint();
          }
        }
  } else {
        AxisAlignedBox3 box;
                
        if (viewSpaceBox)
          box =*viewSpaceBox;
        else 
          box = mKdTree->GetBox();
        
        point = box.GetRandomPoint();
        point.y = viewpoint.y;
  }
        
  return point - viewpoint;
}

Vector3
RssPreprocessor::InitialGetDirection(const Vector3 &viewpoint,
                                                                         AxisAlignedBox3 *viewSpaceBox
                                                                         )
{
  Vector3 point;
  if (!use2dSampling) {
        if (1 || mObjectBasedSampling) {
          Vector3 normal;
          int i = RandomValue(0, mObjects.size()-1);
          Intersectable *object = mObjects[i];
          object->GetRandomSurfacePoint(point, normal);
        } else {
          // select
          if (1 || mDirectionalSampling) {
                point = viewpoint + UniformRandomVector();
          } else {
                // select the other point uniformly distruted in the whole viewspace
                AxisAlignedBox3 box;
                
                if (viewSpaceBox)
                  box =*viewSpaceBox;
                else 
                  box = mKdTree->GetBox();
                
                point = box.GetRandomPoint();
          }
        }
  } else {
        AxisAlignedBox3 box;
        
        if (viewSpaceBox)
          box =*viewSpaceBox;
        else 
          box = mKdTree->GetBox();
        
        point = box.GetRandomPoint();
        point.y = viewpoint.y;
  }
  
  return point - viewpoint;
}

int
RssPreprocessor::GenerateImportanceRays(RssTree *rssTree,
                                                                                const int desiredSamples,
                                                                                SimpleRayContainer &rays
                                                                                )
{
  int num;

  rssTree->UpdateTreeStatistics();

  cout<<
        "#RSS_AVG_PVS_SIZE\n"<<rssTree->stat.avgPvsSize<<endl<<
        "#RSS_AVG_RAYS\n"<<rssTree->stat.avgRays<<endl<<
        "#RSS_AVG_RAY_CONTRIB\n"<<rssTree->stat.avgRayContribution<<endl<<
        "#RSS_AVG_PVS_ENTROPY\n"<<rssTree->stat.avgPvsEntropy<<endl<<
        "#RSS_AVG_RAY_LENGTH_ENTROPY\n"<<rssTree->stat.avgRayLengthEntropy<<endl<<
        "#RSS_AVG_IMPORTANCE\n"<<rssTree->stat.avgImportance<<endl;
  
  if (0) {
        float p = desiredSamples/(float)(rssTree->stat.avgRayContribution*rssTree->stat.Leaves());
        num = rssTree->GenerateRays(p, rays);
  } else {
        int leaves = rssTree->stat.Leaves()/1;
        num = rssTree->GenerateRays(desiredSamples, leaves, rays);
  }
        
  cout<<"Generated "<<num<<" rays."<<endl;
        
  return num;
}


bool
RssPreprocessor::ExportRays(const char *filename,
                                                        const VssRayContainer &vssRays,
                                                        const int number
                                                        )
{
  cout<<"Exporting vss rays..."<<endl<<flush;
        
  Exporter *exporter = NULL;
  exporter = Exporter::GetExporter(filename);
  //    exporter->SetWireframe();
  //    exporter->ExportKdTree(*mKdTree);
  exporter->SetFilled();
  // $$JB temporarily do not export the scene
  if (1)
        exporter->ExportScene(mSceneGraph->mRoot);
  exporter->SetWireframe();

  if (mViewSpaceBox) {
        exporter->SetForcedMaterial(RgbColor(1,0,1));
        exporter->ExportBox(*mViewSpaceBox);
        exporter->ResetForcedMaterial();
  }
        
  VssRayContainer rays;
  
  vssRays.SelectRays( number, rays);

  exporter->ExportRays(rays, RgbColor(1, 0, 0));
        
  delete exporter;

  cout<<"done."<<endl<<flush;

  return true;
}


bool
RssPreprocessor::ExportRssTree(char *filename,
                                                           RssTree *tree,
                                                           const Vector3 &dir
                                                           )
{
  Exporter *exporter = Exporter::GetExporter(filename);
  exporter->SetFilled();
  exporter->ExportScene(mSceneGraph->mRoot);
  //  exporter->SetWireframe();
  bool result = exporter->ExportRssTree2( *tree, dir );
  delete exporter;
  return result;
}

bool
RssPreprocessor::ExportRssTreeLeaf(char *filename,
                                                                   RssTree *tree,
                                                                   RssTreeLeaf *leaf)
{
  Exporter *exporter = NULL;
  exporter = Exporter::GetExporter(filename);
  exporter->SetWireframe();
  exporter->ExportKdTree(*mKdTree);
        
  if (mViewSpaceBox) {
        exporter->SetForcedMaterial(RgbColor(1,0,0));
        exporter->ExportBox(*mViewSpaceBox);
        exporter->ResetForcedMaterial();
  }
        
  exporter->SetForcedMaterial(RgbColor(0,0,1));
  exporter->ExportBox(tree->GetBBox(leaf));
  exporter->ResetForcedMaterial();
        
  VssRayContainer rays[4];
  for (int i=0; i < leaf->rays.size(); i++) {
        int k = leaf->rays[i].GetRayClass();
        rays[k].push_back(leaf->rays[i].mRay);
  }
        
  // SOURCE RAY
  exporter->ExportRays(rays[0], RgbColor(1, 0, 0));
  // TERMINATION RAY
  exporter->ExportRays(rays[1], RgbColor(1, 1, 1));
  // PASSING_RAY
  exporter->ExportRays(rays[2], RgbColor(1, 1, 0));
  // CONTAINED_RAY
  exporter->ExportRays(rays[3], RgbColor(0, 0, 1));

  delete exporter;
  return true;
}

void
RssPreprocessor::ExportRssTreeLeaves(RssTree *tree, const int number)
{
  vector<RssTreeLeaf *> leaves;
  tree->CollectLeaves(leaves);

  int num = 0;
  int i;
  float p = number / (float)leaves.size();
  for (i=0; i < leaves.size(); i++) {
        if (RandomValue(0,1) < p) {
          char filename[64];
          sprintf(filename, "rss-leaf-%04d.x3d", num);
          ExportRssTreeLeaf(filename, tree, leaves[i]);
          num++;
        }
        if (num >= number)
          break;
  }
}


float
RssPreprocessor::GetAvgPvsSize(RssTree *tree,
                                                           const vector<AxisAlignedBox3> &viewcells
                                                           )
{
  vector<AxisAlignedBox3>::const_iterator it, it_end = viewcells.end();

  int sum = 0;
  for (it = viewcells.begin(); it != it_end; ++ it)
        sum += tree->GetPvsSize(*it);
        
  return sum/(float)viewcells.size();
}


void
RssPreprocessor::ExportPvs(char *filename,
                                                   RssTree *rssTree
                                                   )
{
  ObjectContainer pvs;
  if (rssTree->CollectRootPvs(pvs)) {
        Exporter *exporter = Exporter::GetExporter(filename);
        exporter->SetFilled();
        exporter->ExportGeometry(pvs);
        exporter->SetWireframe();
        exporter->ExportBox(rssTree->bbox);
        exporter->ExportViewpoint(rssTree->bbox.Center(), Vector3(1,0,0));
        delete exporter;
  }
}


void
RssPreprocessor::ComputeRenderError()
{
  // compute rendering error
  if (renderer) {
        //      emit EvalPvsStat();
        //      QMutex mutex;
        //      mutex.lock();
        //      renderer->mRenderingFinished.wait(&mutex);
        //      mutex.unlock();

        renderer->EvalPvsStat();
        mStats <<
          "#AvgPvsRenderError\n" <<renderer->mPvsStat.GetAvgError()<<endl<<
          "#MaxPvsRenderError\n" <<renderer->mPvsStat.GetMaxError()<<endl<<
          "#ErrorFreeFrames\n" <<renderer->mPvsStat.GetErrorFreeFrames()<<endl;
  }
}

bool
RssPreprocessor::ComputeVisibility()
{

  if (renderer)
        renderer->InitGL();
  
  //  connect(this, SIGNAL(EvalPvsStat()), renderer, SLOT(EvalPvsStat()) );
  
  cout<<"Rss Preprocessor started\n"<<flush;
  cout<<"Memory/ray "<<sizeof(VssRay)+sizeof(RssTreeNode::RayInfo)<<endl;

  Randomize(0);
  
        
  long startTime = GetTime();
  
  int totalSamples = 0;

  AxisAlignedBox3 *box = new AxisAlignedBox3(mKdTree->GetBox());

  if (fromBoxVisibility) {
        float m = box->Min(1);
        float bsize = box->Size(1);

        float size = 0.02f;
        float s = 0.5f - size;
        float olds = Magnitude(box->Size());
        box->Enlarge(box->Size()*Vector3(-s));
        //      Vector3 translation = Vector3(-olds*0.2f, 0, 0);
        Vector3 translation = Vector3(-0.05f*olds, 0, 0);
        box->SetMin(box->Min() + translation);
        box->SetMax(box->Max() + translation);

        box->SetMin(1,  m + bsize*0.1f);
        box->SetMax(1,  m + bsize*0.6f);

        
  } else {
                
        // sample city like heights
        float m = box->Min(1);
        float bsize = box->Size(1);
        box->SetMin(1,  m + bsize*0.2f);
        box->SetMax(1,  m + bsize*0.3f);
  }

  if (use2dSampling)
        box->SetMax(1, box->Min(1));
        
  if (useViewSpaceBox)
  {
        mViewSpaceBox = box;
        mViewCellsManager->SetViewSpaceBox(*box);
  }
  else
  {
        mViewSpaceBox = NULL;
        mViewCellsManager->SetViewSpaceBox(mKdTree->GetBox());
  }
  
  //-- load view cells from file if requested
  if (mLoadViewCells)
  {     
          // load now because otherwise bounding box not correct
          mViewCellsManager->LoadViewCells(mViewCellsFilename, &mObjects);
  }

  RssTree *rssTree = NULL;
  int rssPass = 0;
  int rssSamples = 0;

#if 0
  if (mLoadInitialSamples) {
        cout << "Loading samples from file ... ";
        LoadSamples(mVssRays, mObjects);
        cout << "finished\n" << endl;
  } else {
#endif
        while (totalSamples < mInitialSamples) {
          int passContributingSamples = 0;
          int passSampleContributions = 0;
          int passSamples = 0;
          int index = 0;
          
          int sampleContributions;
          
          //int s = Min(mSamplesPerPass, mInitialSamples);
          int s = mInitialSamples;

          float probability = 1.0f/mInitialSamples;
          for (int k=0; k < s; k++) {
                
                
                //Vector3 viewpoint = GetViewpoint(mViewSpaceBox);
                Vector3 viewpoint; 
                mViewCellsManager->GetViewPoint(viewpoint);
                //              viewpoint = GetViewpoint(mViewSpaceBox);
                Vector3 direction = InitialGetDirection(viewpoint, mViewSpaceBox);
                
                sampleContributions = CastRay(viewpoint, direction, probability, mVssRays);
                
                
                //-- CORR matt: put block inside loop
                if (sampleContributions) {
                  passContributingSamples ++;
                  passSampleContributions += sampleContributions;
                }
                passSamples++;
                totalSamples++;
          }
          
          
          float avgRayContrib = (passContributingSamples > 0) ? 
                passSampleContributions/(float)passContributingSamples : 0;
          
          cout << "#Pass " << mPass << " : t = " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
          cout << "#TotalSamples=" << totalSamples/1000 
                   << "k   #SampleContributions=" << passSampleContributions << " (" 
                   << 100*passContributingSamples/(float)passSamples<<"%)" 
                   << "avgcontrib=" << avgRayContrib << endl;
          
          mPass++;
        }
          
        cout << "#totalPvsSize=" << mKdTree->CollectLeafPvs() << endl;
        cout << "#totalRayStackSize=" << (int)mVssRays.size() << endl <<flush;
        
        rssSamples += (int)mVssRays.size();
        
        
        if (mExportRays) {
          char filename[64];
          sprintf(filename, "rss-rays-initial.x3d");
          ExportRays(filename, mVssRays, mExportNumRays);
        }
        
        if (mStoreInitialSamples)
          {
                cout << "Writing samples to file ... ";
                ExportSamples(mVssRays);
                cout << "finished\n" << endl;
          }
        
        if (mUseViewcells) {
          // construct view cells
          if (!mLoadViewCells)
                mViewCellsManager->Construct(mObjects, mVssRays);
          // evaluate contributions of the intitial rays
          mViewCellsManager->ComputeSampleContributions(mVssRays);
          
          
          mStats <<
                "#Pass\n" <<mPass<<endl<<
                "#RssPass\n" <<rssPass<<endl<<
                "#Time\n" << TimeDiff(startTime, GetTime())*1e-3<<endl<<
                "#TotalSamples\n" <<totalSamples<<endl<<
                "#RssSamples\n" <<rssSamples<<endl;
          

          mVssRays.PrintStatistics(mStats);
          mViewCellsManager->PrintPvsStatistics(mStats);
          
          VssRayContainer selectedRays;
          int desired = Max(
                                                mViewCellsManager->GetPostProcessSamples(),
                                                mViewCellsManager->GetVisualizationSamples());
          
          mVssRays.SelectRays(desired, selectedRays);
          
          //-- post process view cells
          mViewCellsManager->PostProcess(mObjects, selectedRays);
          
          //-- several visualizations and statistics
          Debug << "view cells after post processing: " << endl;
          mViewCellsManager->PrintStatistics(Debug);
          
          if (1) 
                mViewCellsManager->Visualize(mObjects, selectedRays);

          ComputeRenderError();
          
        }


  
  rssPass++;
  
  rssTree = new RssTree;
  rssTree->SetPass(mPass);
  
  /// compute view cell contribution of rays if view cells manager already constructed
  mViewCellsManager->ComputeSampleContributions(mVssRays);

  if (mUseImportanceSampling) {
        
        //      if (fromBoxVisibility)
        //        rssTree->Construct(mObjects, mVssRays, mViewSpaceBox);
        //      else
        rssTree->Construct(mObjects, mVssRays);

        rssTree->stat.Print(mStats);
        cout<<"RssTree root PVS size = "<<rssTree->GetRootPvsSize()<<endl;
        
        if (mExportRssTree) {
          ExportRssTree("rss-tree-100.x3d", rssTree, Vector3(1,0,0));
          ExportRssTree("rss-tree-001.x3d", rssTree, Vector3(0,0,1));
          ExportRssTree("rss-tree-101.x3d", rssTree, Vector3(1,0,1));
          ExportRssTree("rss-tree-101m.x3d", rssTree, Vector3(-1,0,-1));
          ExportRssTreeLeaves(rssTree, 10);
        }
        
        if (mExportPvs) {
          ExportPvs("rss-pvs-initial.x3d", rssTree);
        }
  }
  
  // viewcells->UpdatePVS(newVssRays);
  

  while (1) {
        int num = mRssSamplesPerPass;
        SimpleRayContainer rays;
        VssRayContainer vssRays;


        if (!mUseImportanceSampling) {
          for (int j=0; j < num; j++) {
            //changed by matt
                //Vector3 viewpoint = GetViewpoint(mViewSpaceBox); 
                Vector3 viewpoint; 
                mViewCellsManager->GetViewPoint(viewpoint);
                Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
                rays.push_back(SimpleRay(viewpoint, direction, 1.0f));
                rays.mSumPdf += 1.0f;
          }
        } else {
          num = GenerateImportanceRays(rssTree, num, rays);
        }

        rays.NormalizePdf();
        
        for (int i=0; i < rays.size(); i++)
          CastRay(rays[i].mOrigin, rays[i].mDirection, rays[i].mPdf, vssRays);

        
        totalSamples += (int)rays.size();
        rssSamples += (int)vssRays.size();

        
        
        mStats <<
          "#Pass\n" <<mPass<<endl<<
          "#RssPass\n" <<rssPass<<endl<<
          "#Time\n" << TimeDiff(startTime, GetTime())*1e-3<<endl<<
          "#TotalSamples\n" <<totalSamples<<endl<<
          "#RssSamples\n" <<rssSamples<<endl;


        if (mUseViewcells) {
          
          /// compute view cell contribution of rays
          mViewCellsManager->ComputeSampleContributions(vssRays);
          
          vssRays.PrintStatistics(mStats);
          mViewCellsManager->PrintPvsStatistics(mStats);
        }


        ComputeRenderError();
        
        // epxort rays before adding them to the tree -> some of them can be deleted

        if (mExportRays) {
          char filename[64];
          if (mUseImportanceSampling)
                sprintf(filename, "rss-rays-i%04d.x3d", rssPass);
          else
                sprintf(filename, "rss-rays-%04d.x3d", rssPass);
          
          ExportRays(filename, vssRays, mExportNumRays);

          // now export all contributing rays
          VssRayContainer contributingRays;
          vssRays.GetContributingRays(contributingRays, mPass);
          mStats<<"#NUM_CONTRIBUTING_RAYS\n"<<(int)contributingRays.size()<<endl;
          sprintf(filename, "rss-crays-%04d.x3d", rssPass);
          ExportRays(filename, contributingRays, mExportNumRays);
        }

        
        // add rays to the tree after the viewcells have been cast to have their contributions
        // already when adding into the tree
        // do not add those rays which have too low or no contribution....
        
        if (mUseImportanceSampling) {
          rssTree->AddRays(vssRays);
          
          if (0) {
                cout<<"############# Rss PVS STAT ##################\n";
                cout<<"#AVG_RSS_PVS\n"<<rssTree->GetAvgPvsSize()<<endl;
                cout<<"#RSS_ROOT_PVS\n"<<rssTree->GetRootPvsSize()<<endl;
          }
          
          
          if (mUpdateSubdivision) {
                int updatePasses = 1;
                if (mPass % updatePasses == 0) {
                  int subdivided = rssTree->UpdateSubdivision();
                  cout<<"subdivided leafs = "<<subdivided<<endl;
                  cout<<"#total leaves = "<<rssTree->stat.Leaves()<<endl;
                }
          }
        }
        

        
        if (mExportPvs) {
          char filename[64];
          sprintf(filename, "rss-pvs-%04d.x3d", rssPass);
          ExportPvs(filename, rssTree);
        }

        
        if (!mUseImportanceSampling) 
          CLEAR_CONTAINER(vssRays);

        if (totalSamples >= mRssSamples + mInitialSamples)
          break;

        
        rssPass++;
        mPass++;
        rssTree->SetPass(mPass);
  }
  
  if (mUseViewcells) {

        
        //-- render simulation after merge
        cout << "\nevaluating bsp view cells render time after merge ... ";
        
        mRenderSimulator->RenderScene();
        SimulationStatistics ss;
        mRenderSimulator->GetStatistics(ss);
        
        cout << " finished" << endl;
        cout << ss << endl;
        Debug << ss << endl;
        
  }

  cerr<<"Deleting RSS tree...\n";
  delete rssTree;
  cerr<<"Done.\n";

  
  return true;
}