source: GTP/trunk/Lib/Vis/Preprocessing/src/CombinedPreprocessor.cpp @ 2726

#include "SceneGraph.h"
#include "KdTree.h"
#include "X3dExporter.h"
#include "Environment.h"
#include "Polygon3.h"
#include "VssRay.h"
#include "RssTree.h"
#include "ViewCellsManager.h"
#include "RenderSimulator.h"
#include "GlRenderer.h"
#include "SamplingStrategy.h"
#include "PreprocessorThread.h"
#include "CombinedPreprocessor.h"
#include "RayCaster.h"
#include <windows.h> 


namespace GtpVisibilityPreprocessor {


const bool pruneInvalidRays = true;

  
  CombinedPreprocessor::CombinedPreprocessor():
        Preprocessor()
  {
        // this should increase coherence of the samples
//      Environment::GetSingleton()->GetIntValue("RssPreprocessor.vssSamples", mTotalSamples);
//      Environment::GetSingleton()->GetIntValue("RssPreprocessor.samplesPerPass", mSamplesPerPass);
//      Environment::GetSingleton()->GetIntValue("RssPreprocessor.vssSamplesPerPass",
//                                                                                       mSamplesPerEvaluation);
        
        
  }



bool
CombinedPreprocessor::ComputeVisibility()
{
  
  Debug << "Preprocessor type: combined" << endl;
  cout<<"Combined Preprocessor started\n"<<flush;
  
  // 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);
  }
  
  
  // now decode distribution string
  char buff[1024];
  Environment::GetSingleton()->GetStringValue("RssPreprocessor.distributions",
                                                                                          buff);
  
  
  mMixtureDistribution = new MixtureDistribution(*this);
  mMixtureDistribution->Construct(buff);
  
  SimpleRayContainer rays;
  VssRayContainer vssRays;

  int lastEvaluation = 0;
 
  mPass = 0;
  
  vector<VssRayContainer> rayBuffer;
  rays.reserve(mSamplesPerPass);
  rayBuffer.reserve(2*mSamplesPerPass);
  
  long startTime = GetTime();

  mCurrentSamples = 0;

  for (mCurrentSamples =0; mCurrentSamples < mTotalSamples; mCurrentSamples += mSamplesPerPass, mPass++) {
          while (mSynchronize)
          {
                  // hack: sleep during walthrough computation
                  Sleep(1000);
          }

        mRayCaster->InitPass();
        
        cout<<"Progress :"<<mCurrentSamples/1e6f<<"M rays, "<<(100.0f*mCurrentSamples)/mTotalSamples<<"%"<<endl;
        
        rays.clear();
        vssRays.clear();
        
        int invalidSamples = 0;
        mMixtureDistribution->GenerateSamples(mSamplesPerPass, rays, invalidSamples);

        cerr<<"Casting rays..."<<endl;
        
        bool doubleRays = true;
        CastRays(rays, vssRays, doubleRays, pruneInvalidRays);
        mTotalRaysCast += (int)vssRays.size();

        cerr<<"Done..."<<endl;

        cerr<<"Computing ray contributions..."<<endl;
        mMixtureDistribution->ComputeContributions(vssRays);
        cerr<<"Done..."<<endl;


        if (mExportRays) {
          Debug<<"Exporting rays..."<<endl<<flush;
          char filename[256];

          VssRayContainer contributingRays;
          vssRays.GetContributingRays(contributingRays, 0);
          sprintf(filename, "rss-crays-%04d.x3d", mPass);
          ExportRays(filename, contributingRays, mExportNumRays);

          sprintf(filename, "rss-rays-i%04d.x3d", mPass);
          ExportRays(filename, vssRays, mExportNumRays);


          if (mExportAnimation) {
                rayBuffer.push_back(VssRayContainer());
                vssRays.SelectRays(mExportNumRays, rayBuffer[rayBuffer.size()-1], true);
          }

          Debug<<"done."<<endl<<flush;
        }
        
        mMixtureDistribution->UpdateDistributions(vssRays);
        
        if (mCurrentSamples - lastEvaluation >= mSamplesPerEvaluation) {
          Real time = TimeDiff(startTime, GetTime());
#if 0 // matt: remove temporarily
          mViewCellsManager->PrintPvsStatistics(mStats);
#endif
          mStats <<
                "#Pass\n" <<mPass<<endl<<
                "#Time\n" << time <<endl<<
                "#TotalSamples\n" << mCurrentSamples <<endl<<
                "#RssSamples\n" <<mTotalRaysCast<<endl;

          float last = 0.0f;
          for (int k=0; k < 6; k++) {
                float ratio = 0.0f;
                if (k < mMixtureDistribution->mDistributions.size()) {
                  ratio = mMixtureDistribution->mDistributions[k]->mRatio-last;
                  last = mMixtureDistribution->mDistributions[k]->mRatio;;
                }
                mStats <<
                  "#Distribution"<<k<<endl<<
                  ratio<<endl;
          }
          
          lastEvaluation = mCurrentSamples;
          
          if (renderer) {
                cout<<"Evaluating render error"<<endl;
                ComputeRenderError();
                cout<<"finished evaluating error"<<endl;
          }
        }
        
        
        Real time = TimeDiff(startTime, GetTime());
        if (mTotalTime!= -1 && time/1000 > mTotalTime)
          break;

#if 0
        cerr<<"deleting rays"<<endl;
        //clear all unreferenced rays
        for (int j=0; j < vssRays.size(); j++) {
          if (vssRays[j]->RefCount() == 0)
                delete vssRays[j];
        }
        cerr<<"done."<<endl;
#endif  
        
        //      if (!mMixtureDistribution->RequiresRays())
        //        CLEAR_CONTAINER(vssRays);

        
  }
  
  EvalViewCellHistogram();

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

  return true;
}

}