source: GTP/trunk/Lib/Vis/Preprocessing/src/RssPreprocessor.cpp @ 1824

#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"
#include "SamplingStrategy.h"



namespace GtpVisibilityPreprocessor {


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


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

#define ADD_RAYS_IN_PLACE 1
  
RssPreprocessor::RssPreprocessor():
  mVssRays()
{
  // this should increase coherence of the samples
  Environment::GetSingleton()->GetIntValue("RssPreprocessor.samplesPerPass", mSamplesPerPass);
  Environment::GetSingleton()->GetIntValue("RssPreprocessor.initialSamples", mInitialSamples);
  Environment::GetSingleton()->GetIntValue("RssPreprocessor.vssSamples", mRssSamples);
  Environment::GetSingleton()->GetIntValue("RssPreprocessor.vssSamplesPerPass", mRssSamplesPerPass);
  Environment::GetSingleton()->GetBoolValue("RssPreprocessor.useImportanceSampling", mUseImportanceSampling);

  Environment::GetSingleton()->GetBoolValue("RssPreprocessor.useRssTree",
                                                                                        mUseRssTree);

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

  Environment::GetSingleton()->GetBoolValue("RssPreprocessor.loadInitialSamples", mLoadInitialSamples);

  Environment::GetSingleton()->GetBoolValue("RssPreprocessor.storeInitialSamples", mStoreInitialSamples);

  Environment::GetSingleton()->GetBoolValue("RssPreprocessor.updateSubdivision", mUpdateSubdivision);
  
  mRssTree = NULL;
}


int
RssPreprocessor::GenerateRays(
                                                          const int number,
                                                          const int sampleType,
                                                          SimpleRayContainer &rays
                                                          )
{
  int result = 0;
  
  Debug<<"Generate rays...\n"<<flush;

  switch (sampleType) {
  case SamplingStrategy::RSS_BASED_DISTRIBUTION:
  case SamplingStrategy::RSS_SILHOUETTE_BASED_DISTRIBUTION:
                if (mRssTree) {
                        result = GenerateImportanceRays(mRssTree, number, rays);
                }
                break;
                
  default:
                result = Preprocessor::GenerateRays(number, sampleType, rays);
  }

  //  rays.NormalizePdf();
  Debug<<"done.\n"<<flush;

  return result;
}




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



void
RssPreprocessor::ExportObjectRays(VssRayContainer &rays,
                                                                  const int objectId)
{
  ObjectContainer::const_iterator oi;

  Intersectable *object = NULL;
  for (oi = mObjects.begin(); oi != mObjects.end(); ++oi)
        if (objectId == (*oi)->GetId()) {
          object = *oi;
          break;
        }

  if (object == NULL)
        return;
  
  VssRayContainer selectedRays;
  VssRayContainer::const_iterator it= rays.begin(), it_end = rays.end();

  
  for (; it != it_end; ++it) {
        if ((*it)->mTerminationObject == object)
          selectedRays.push_back(*it);
  }
  

  Exporter *exporter = Exporter::GetExporter("object-rays.x3d");
  //    exporter->SetWireframe();
  //    exporter->ExportKdTree(*mKdTree);
  exporter->SetFilled();
  exporter->ExportIntersectable(object);
  exporter->ExportRays(selectedRays, RgbColor(1, 0, 0));
  
  delete exporter;
  
}


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);
  }
        
        
  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);
  if (0) {
        exporter->SetWireframe();
        exporter->ExportKdTree(*mKdTree);
  }
  exporter->SetFilled();
  // $$JB temporarily do not export the scene
  if (0)
        exporter->ExportScene(mSceneGraph->GetRoot());
  exporter->SetWireframe();

  if (1) {
        exporter->SetForcedMaterial(RgbColor(1,0,1));
        exporter->ExportBox(mViewCellsManager->GetViewSpaceBox());
        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::ExportRayAnimation(const char *filename,
                                                                        const vector<VssRayContainer> &vssRays
                                                                        )
{
  cout<<"Exporting vss rays..."<<endl<<flush;
        
  Exporter *exporter = NULL;
  exporter = Exporter::GetExporter(filename);
  if (0) {
        exporter->SetWireframe();
        exporter->ExportKdTree(*mKdTree);
  }
  exporter->SetFilled();
  // $$JB temporarily do not export the scene
  if (1)
        exporter->ExportScene(mSceneGraph->GetRoot());
  exporter->SetWireframe();

  if (1) {
        exporter->SetForcedMaterial(RgbColor(1,0,1));
        exporter->ExportBox(mViewCellsManager->GetViewSpaceBox());
        exporter->ResetForcedMaterial();
  }
  
  exporter->ExportRaySets(vssRays, 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->GetRoot());
  //  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);
        
  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 && renderer->mPvsStatFrames) {
        //      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<<
          "#AvgRenderPvs\n" <<renderer->mPvsStat.GetAvgPvs()<<endl;
  }
}

void
NormalizeRatios(vector<SamplingStrategy *> &distributions)
{
  int i;
  float sumRatios = 0.0f;
  
  for (i=0; i < distributions.size(); i++)
        sumRatios += distributions[i]->mRatio;

  
  if (sumRatios == 0.0f) {
        for (i=0; i < distributions.size(); i++) {
          distributions[i]->mRatio = 1.0f;
          sumRatios += 1.0f;
        }
  }

  for (i=0 ; i < distributions.size(); i++)
        distributions[i]->mRatio/=sumRatios;

#define MIN_RATIO 0.1f
  
  for (i = 0; i < distributions.size(); i++)
        if (distributions[i]->mRatio < MIN_RATIO)
          distributions[i]->mRatio = MIN_RATIO;


  sumRatios = 0.0f;
  for (i=0; i < distributions.size(); i++)
        sumRatios += distributions[i]->mRatio;

  for (i=0 ; i < distributions.size(); i++)
        distributions[i]->mRatio/=sumRatios;
  
  
  cout<<"New ratios: ";
  for (i=0 ; i < distributions.size(); i++)
        cout<<distributions[i]->mRatio<<" ";
  cout<<endl;
}

void
EvaluateRatios(vector<SamplingStrategy *> &distributions)
{
  // now evaluate the ratios for the next pass
#define TIME_WEIGHT 0.5f
  for (int i=0; i < distributions.size(); i++) {
        distributions[i]->mRatio = distributions[i]->mContribution/
          (TIME_WEIGHT*distributions[i]->mTime +
           (1 - TIME_WEIGHT)*distributions[i]->mRays);

#if 1
        distributions[i]->mRatio = sqr(distributions[i]->mRatio);
#endif
  }
}



bool
RssPreprocessor::ComputeVisibility()
{

  Debug << "type: rss" << endl;

  cout<<"Rss Preprocessor started\n"<<flush;
  //  cout<<"Memory/ray "<<sizeof(VssRay)+sizeof(RssTreeNode::RayInfo)<<endl;

  Randomize(0);
  
  // use ray buffer to export ray animation
  const bool useRayBuffer = false;
  
  vector<VssRayContainer> rayBuffer(50);
  
  long startTime = GetTime();
  long lastTime;
  float totalTime;
  
  int totalSamples = 0;

  // if not already loaded, construct view cells from file
  if (!mLoadViewCells)
  {
          // construct view cells using it's own set of samples
          mViewCellsManager->Construct(this);

          //-- several visualizations and statistics
          Debug << "view cells construction finished: " << endl;
          mViewCellsManager->PrintStatistics(Debug);
  }

  
  int rssPass = 0;
  int rssSamples = 0;

  if (mUseRssTree)
                mDistributions.push_back(new RssBasedDistribution(*this));


        if (1) {
                //  mDistributions.push_back(new SpatialBoxBasedDistribution(*this));
                //  mDistributions.push_back(new DirectionBasedDistribution(*this));
                mDistributions.push_back(new ObjectDirectionBasedDistribution(*this));
                //  mDistributions.push_back(new ReverseObjectBasedDistribution(*this));
                mDistributions.push_back(new ObjectBasedDistribution(*this));
                mDistributions.push_back(new ReverseViewSpaceBorderBasedDistribution(*this));
        } else {
                mDistributions.push_back(new GlobalLinesDistribution(*this));
        }
  
  if (mLoadInitialSamples) {
        cout << "Loading samples from file ... ";
        LoadSamples(mVssRays, mObjects);
        cout << "finished\n" << endl;
  } else {
        SimpleRayContainer rays;
        
        cout<<"Generating initial rays..."<<endl<<flush;
        
        if (mUseImportanceSampling) {
          int count = 0;
          int i;

          // Generate initial samples
          for (i=0; i < mDistributions.size(); i++)
                if (mDistributions[i]->mType != SamplingStrategy::RSS_BASED_DISTRIBUTION)
                  count++;
          
          for (i=0; i < mDistributions.size(); i++)
                if (mDistributions[i]->mType != SamplingStrategy::RSS_BASED_DISTRIBUTION)
                  GenerateRays(mInitialSamples/count,
                                                                         mDistributions[i]->mType,
                                                                         rays);

        } else {
          int rayType = SamplingStrategy::SPATIAL_BOX_BASED_DISTRIBUTION;
          if (mObjectBasedSampling)
                rayType = SamplingStrategy::OBJECT_BASED_DISTRIBUTION;
          else
                if (mDirectionalSampling)
                  rayType = SamplingStrategy::DIRECTION_BASED_DISTRIBUTION;
          cout<<"Generating rays..."<<endl;
          GenerateRays(mRssSamplesPerPass, rayType, rays);
        }
        
        
        cout<<"Casting initial rays..."<<endl<<flush;
        CastRays(rays, mVssRays, true);

        ExportObjectRays(mVssRays, 1546);
  }
  
  cout << "#totalRayStackSize=" << (int)mVssRays.size() << endl <<flush;
  
  rssSamples += (int)mVssRays.size();
  totalSamples += mInitialSamples;
  mPass++;
  
  if (mExportRays) {
        
        char filename[64];
        sprintf(filename, "rss-rays-initial.x3d");
        ExportRays(filename, mVssRays, mExportNumRays);

        if (useRayBuffer)
          mVssRays.SelectRays(mExportNumRays, rayBuffer[0], true);
        
  }
  
  if (mStoreInitialSamples) {
        cout << "Writing samples to file ... ";
        ExportSamples(mVssRays);
        cout << "finished\n" << endl;
  }
        
  if (mUseViewcells) {

        cout<<"Computing sample contributions..."<<endl<<flush;
        // evaluate contributions of the intitial rays
        mViewCellsManager->ComputeSampleContributions(mVssRays, true, false);
        cout<<"done.\n"<<flush;

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

        {
          VssRayContainer contributingRays;
          mVssRays.GetContributingRays(contributingRays, 0);
          mStats<<"#NUM_CONTRIBUTING_RAYS\n"<<(int)contributingRays.size()<<endl;
          if (mExportRays) {
                char filename[64];
                sprintf(filename, "rss-crays-%04d.x3d", 0);
                ExportRays(filename, contributingRays, mExportNumRays);
          }
        }
        
          
        // viewcells->UpdatePVS(newVssRays);
        Debug<<"Valid viewcells before set validity: "<<mViewCellsManager->CountValidViewcells()<<endl;
        // cull viewcells with PVS > median (0.5f)
        //mViewCellsManager->SetValidityPercentage(0, 0.5f); 
        mViewCellsManager->SetValidityPercentage(0, 1.0f); 
        Debug<<"Valid viewcells after set validity: "<<mViewCellsManager->CountValidViewcells()<<endl;

        mVssRays.PrintStatistics(mStats);
        mViewCellsManager->PrintPvsStatistics(mStats);

        ComputeRenderError();
  }
  
  rssPass++;

        //      mDistributions.resize(1);

  mRssTree = new RssTree;
  mRssTree->SetPass(mPass);
  
  /// compute view cell contribution of rays if view cells manager already constructed
  //  mViewCellsManager->ComputeSampleContributions(mVssRays, true, false);

  if (mUseImportanceSampling) {

        if (mUseRssTree) {
          mRssTree->Construct(mObjects, mVssRays);
        
          mRssTree->stat.Print(mStats);
          cout<<"RssTree root PVS size = "<<mRssTree->GetRootPvsSize()<<endl;
          
          if (mExportRssTree) {
                ExportRssTree("rss-tree-100.x3d", mRssTree, Vector3(1,0,0));
                ExportRssTree("rss-tree-001.x3d", mRssTree, Vector3(0,0,1));
                ExportRssTree("rss-tree-101.x3d", mRssTree, Vector3(1,0,1));
                ExportRssTree("rss-tree-101m.x3d", mRssTree, Vector3(-1,0,-1));
                ExportRssTreeLeaves(mRssTree, 10);
          }
        }

        if (mExportPvs) {
          ExportPvs("rss-pvs-initial.x3d", mRssTree);
        }
  }
  
  

  while (1) {

        static SimpleRayContainer rays;
        static VssRayContainer vssRays;
        static VssRayContainer tmpVssRays;

        rays.reserve((int)(1.1f*mRssSamplesPerPass));

        rays.clear();
        vssRays.clear();
        tmpVssRays.clear();

        int castRays = 0;
        if (mUseImportanceSampling) {

          NormalizeRatios(mDistributions);
          
          long t1;

          for (int i=0; i < mDistributions.size(); i++) {
                t1 = GetTime();
                rays.clear();
                tmpVssRays.clear();
                if (mDistributions[i]->mRatio != 0) {
                  GenerateRays(int(mRssSamplesPerPass*mDistributions[i]->mRatio),
                                           mDistributions[i]->mType,
                                           rays);
                  
                  rays.NormalizePdf((float)rays.size());
                  
                  CastRays(rays, tmpVssRays, true);
                  castRays += (int)rays.size();
                  
#if ADD_RAYS_IN_PLACE 
                  mDistributions[i]->mContribution =
                        mViewCellsManager->ComputeSampleContributions(tmpVssRays, true, false);
#else
                  mDistributions[i]->mContribution =
                        mViewCellsManager->ComputeSampleContributions(tmpVssRays, false, true);
#endif
                }

                mDistributions[i]->mTime = TimeDiff(t1, GetTime());
                mDistributions[i]->mRays = (int)rays.size();
                //              mStats<<"#RssRelContrib"<<endl<<contributions[0]/nrays[0]<<endl;
                vssRays.insert(vssRays.end(), tmpVssRays.begin(), tmpVssRays.end() );
          }

          EvaluateRatios(mDistributions);
          
          // add contributions of all rays at once...
#if !ADD_RAYS_IN_PLACE 
          mViewCellsManager->AddSampleContributions(vssRays);
#endif    
        }
        else {
                int rayType = SamplingStrategy::SPATIAL_BOX_BASED_DISTRIBUTION;
          if (mObjectBasedSampling)
                  rayType = SamplingStrategy::OBJECT_BASED_DISTRIBUTION;
          else
                if (mDirectionalSampling)
                        rayType = SamplingStrategy::DIRECTION_BASED_DISTRIBUTION;

          cout<<"Generating rays..."<<endl;

          GenerateRays(mRssSamplesPerPass, rayType, rays);
          cout<<"done."<<endl;

          cout<<"Casting rays..."<<endl;          CastRays(rays, vssRays, true);
          cout<<"done."<<endl;
          castRays += (int)rays.size();
          if (mUseViewcells) {
                /// compute view cell contribution of rays
                cout<<"Computing sample contributions..."<<endl;
                mViewCellsManager->ComputeSampleContributions(vssRays, true, false);
                cout<<"done."<<endl;
          }
                
          
        }
        totalSamples += castRays;
        rssSamples += (int)vssRays.size();

        cout<<"Generated "<<castRays<<" rays, progress "<<100.0f*totalSamples/((float) mRssSamples +
                                                                                                                                                   mInitialSamples)<<"%\n";
        

        long time = GetTime();
        totalTime += TimeDiff(lastTime, time);
        lastTime = time;
        
        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) {
          Debug<<"Print statistics...\n"<<flush;
          vssRays.PrintStatistics(mStats);
          mViewCellsManager->PrintPvsStatistics(mStats);
          Debug<<"done.\n"<<flush;
        }


        if (renderer && mPass > 0) {
          char buf[100];
          if (mUseImportanceSampling)
                {
                  sprintf(buf, "snap/i-%02d-", mPass);
                  
                  renderer->SetSnapPrefix(buf);
                }
          else
                {
                  sprintf(buf, "snap/r-%02d-", mPass);
                  
                  renderer->SetSnapPrefix(buf);
                }
          
          renderer->SetSnapErrorFrames(true);
        }
        
        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);
          
          

          if (useRayBuffer)
                vssRays.SelectRays(mExportNumRays, rayBuffer[mPass], true);
          
          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 (mUseRssTree && mUseImportanceSampling) {
          Debug<<"Adding rays...\n"<<flush;
          mRssTree->AddRays(vssRays);
          Debug<<"done.\n"<<flush;
          if (mUpdateSubdivision) {
                int updatePasses = 1;
                if (mPass % updatePasses == 0) {
                  Debug<<"Updating rss tree...\n"<<flush;
                  int subdivided = mRssTree->UpdateSubdivision();
                  Debug<<"done.\n"<<flush;
                  cout<<"subdivided leafs = "<<subdivided<<endl;
                  cout<<"#total leaves = "<<mRssTree->stat.Leaves()<<endl;
                }
          }
        }
        
        if (mExportPvs) {
          char filename[64];
          sprintf(filename, "rss-pvs-%04d.x3d", rssPass);
          ExportPvs(filename, mRssTree);
        }
        
        
        if (!mUseImportanceSampling || !mUseRssTree)
          CLEAR_CONTAINER(vssRays);
        // otherwise the rays get deleted by the rss tree update according to RssTree.maxRays ....
        
        if (totalSamples >= mRssSamples + mInitialSamples)
          break;
        
        
        rssPass++;
        mPass++;
        mRssTree->SetPass(mPass);
  }
  
  if (mUseViewcells) {

        if(0) {
          VssRayContainer selectedRays;
          int desired = mViewCellsManager->GetVisualizationSamples();
          
          mVssRays.SelectRays(desired, selectedRays);
          
          mViewCellsManager->Visualize(mObjects, selectedRays);
          }
        
        // view cells after sampling
        mViewCellsManager->PrintStatistics(Debug);
        
        EvalViewCellHistogram();
        
        //-- render simulation after merge
        cout << "\nevaluating bsp view cells render time after sampling ... ";
        
        mRenderSimulator->RenderScene();
        SimulationStatistics ss;
        mRenderSimulator->GetStatistics(ss);
        
        cout << " finished" << endl;
        cout << ss << endl;
        Debug << ss << endl;
  }


  if (useRayBuffer&& mExportRays && mUseImportanceSampling) {
        char filename[64];
        sprintf(filename, "rss-rays-i.x3d");
        
        rayBuffer.resize(mPass);
        ExportRayAnimation(filename, rayBuffer);
  }
          

  // do not delete rss tree now - can be used for visualization..
#if 0
  Debug<<"Deleting RSS tree...\n";
  delete mRssTree;
  Debug<<"Done.\n";
#endif

  //mViewCellsManager->ExportViewCells("visibility.xml",
  //                                                                     true);
  
  
  return true;
}

}