source: GTP/trunk/Lib/Vis/Preprocessing/src/VssPreprocessor.cpp @ 2542

#include "SceneGraph.h"
#include "KdTree.h"
#include "VssPreprocessor.h"
#include "X3dExporter.h"
#include "Environment.h"
#include "MutualVisibility.h"
#include "Polygon3.h"
#include "ViewCell.h"
#include "VssRay.h"
#include "VssTree.h"
#include "ViewCellsManager.h"
#include "RenderSimulator.h"
#include "Beam.h"
#include "GlRenderer.h"
#include "Intersectable.h"
#include "RayCaster.h"
#include "SamplingStrategy.h"
#include "ViewCellBsp.h"


namespace GtpVisibilityPreprocessor {


bool use2dSampling = false;
bool useViewspacePlane = false;

VssPreprocessor::VssPreprocessor():
  mVssRays()
{
  // this should increase coherence of the samples
  //  Environment::GetSingleton()->GetIntValue("VssPreprocessor.samplesPerPass", mSamplesPerPass);
  //  Environment::GetSingleton()->GetIntValue("VssPreprocessor.initialSamples", mInitialSamples);
  //  Environment::GetSingleton()->GetIntValue("VssPreprocessor.vssSamples", mVssSamples);
  //  Environment::GetSingleton()->GetIntValue("VssPreprocessor.vssSamplesPerPass", mVssSamplesPerPass);
  Environment::GetSingleton()->GetBoolValue("VssPreprocessor.useImportanceSampling", mUseImportanceSampling);
 
  Environment::GetSingleton()->GetBoolValue("VssPreprocessor.loadInitialSamples", mLoadInitialSamples);
  Environment::GetSingleton()->GetBoolValue("VssPreprocessor.storeInitialSamples", mStoreInitialSamples);
  Environment::GetSingleton()->GetBoolValue("VssPreprocessor.testBeamSampling", mTestBeamSampling);
  Environment::GetSingleton()->GetBoolValue("VssPreprocessor.enlargeViewSpace", mEnlargeViewSpace);
  Environment::GetSingleton()->GetBoolValue("Preprocessor.detectEmptyViewSpace", mDetectEmptyViewSpace);
  
  useViewspacePlane = mUseViewSpaceBox; //hack
  
  Debug << "*********** vss preprocessor options **************" << endl;
  Debug << "use view space box=" << mUseViewSpaceBox << endl;
  Debug << "enlarge view space=" << mEnlargeViewSpace << endl;
  Debug << "*********** end vss preprocessor options **************" << endl;

}


VssPreprocessor::~VssPreprocessor()
{
        CLEAR_CONTAINER(mVssRays);
}


Vector3
VssPreprocessor::GetViewpoint(AxisAlignedBox3 *viewSpaceBox)
{
  AxisAlignedBox3 box;

  if (viewSpaceBox)
        box =*viewSpaceBox;
  else
        box = mKdTree->GetBox();

  // shrink the box in the y direction
  return box.GetRandomPoint();
}

Vector3
VssPreprocessor::GetDirection(const Vector3 &viewpoint,
                                                          AxisAlignedBox3 *viewSpaceBox
                                                          )
{
  Vector3 point;
  if (!use2dSampling) 
  {
          if (0) 
          {
                  Vector3 normal;
                  int i = Random((int)mObjects.size());
                  Intersectable *object = mObjects[i];
                  object->GetRandomSurfacePoint(point, normal);
          } 
          else
                  point = mKdTree->GetBox().GetRandomPoint();
        //        point = viewpoint + UniformRandomVector();
  } 
  else 
  {
          AxisAlignedBox3 box;

          if (viewSpaceBox)
                  box =*viewSpaceBox;
          else
                  box = mKdTree->GetBox();

          point = box.GetRandomPoint();
          point.y = viewpoint.y;
  }

  return point - viewpoint;
}

int
VssPreprocessor::GenerateImportanceRays(VssTree *vssTree,
                                                                                const int desiredSamples,
                                                                                SimpleRayContainer &rays
                                                                                )
{
  int num;
  if (0) {
        float minRayContribution;
        float maxRayContribution;
        float avgRayContribution;

        vssTree->GetRayContributionStatistics(minRayContribution,
                                                                                  maxRayContribution,
                                                                                  avgRayContribution);

        cout<<
          "#MIN_RAY_CONTRIB\n"<<minRayContribution<<endl<<
          "#MAX_RAY_CONTRIB\n"<<maxRayContribution<<endl<<
          "#AVG_RAY_CONTRIB\n"<<avgRayContribution<<endl;

        float p = desiredSamples/(float)(avgRayContribution*vssTree->stat.Leaves());
        num = vssTree->GenerateRays(p, rays);
  } else {
        int leaves = vssTree->stat.Leaves();
        num = vssTree->GenerateRays(desiredSamples, leaves, rays);
  }

  cout<<"Generated "<<num<<" rays."<<endl;

  return num;
}


bool
VssPreprocessor::ExportRays(const char *filename,
                                                        const VssRayContainer &vssRays,
                                                        const int number,
                                                        const bool exportScene
                                                        )
{
  cout<<"Exporting vss rays..."<<endl<<flush;

  Exporter *exporter = NULL;
  exporter = Exporter::GetExporter(filename);
  exporter->SetWireframe();
  exporter->ExportKdTree(*mKdTree);
  exporter->SetFilled();
  exporter->ExportScene(mSceneGraph->GetRoot());
  exporter->SetWireframe();

  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
VssPreprocessor::ExportVssTree(char *filename,
                                                           VssTree *tree,
                                                           const Vector3 &dir
                                                           )
{
  Exporter *exporter = Exporter::GetExporter(filename);
  exporter->SetFilled();
  exporter->ExportScene(mSceneGraph->GetRoot());
  //  exporter->SetWireframe();
  bool result = exporter->ExportVssTree2( *tree, dir );
  delete exporter;
  return result;
}

bool
VssPreprocessor::ExportVssTreeLeaf(char *filename,
                                                                   VssTree *tree,
                                                                   VssTreeLeaf *leaf)
{
  Exporter *exporter = NULL;
  exporter = Exporter::GetExporter(filename);
  exporter->SetWireframe();
  exporter->ExportKdTree(*mKdTree);

  exporter->SetForcedMaterial(RgbColor(1,0,0));
  exporter->ExportBox(mViewCellsManager->GetViewSpaceBox());
  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
VssPreprocessor::ExportVssTreeLeaves(VssTree *tree, const int number)
{
  vector<VssTreeLeaf *> 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, "vss-leaf-%04d.x3d", num);
          ExportVssTreeLeaf(filename, tree, leaves[i]);
          num++;
        }
        if (num >= number)
          break;
  }
}


void VssPreprocessor::TestBeamCasting(VssTree *tree, 
                                                                          ViewCellsManager *vm, 
                                                                          const ObjectContainer &objects)
{
        //debuggerWidget = new GlDebuggerWidget(renderer);
        //renderer->resize(640, 480);
        //debuggerWidget->resize(640, 480);

        vector<VssTreeLeaf *> leaves;
        tree->CollectLeaves(leaves);

        Exporter *exporter = Exporter::GetExporter("shafts.x3d");

        exporter->SetWireframe();
        exporter->ExportGeometry(objects);
        exporter->SetFilled();
        
        //Randomize();
        //§§matt
        //debuggerWidget = new GlDebuggerWidget(renderer);

        /*
        debuggerWidget->mBeam = beam;
        debuggerWidget->mSourceObject = sourceObj;
        debuggerWidget->mSamples = 10000;
        
        Debug << "showing window" << endl;
        debuggerWidget->show();
        
        renderer->makeCurrent();
        */

        for (int i = 0; i < 10; ++ i)
        {
                Beam beam;
                Intersectable *sourceObj = mObjects[5];

                const int index = (int)RandomValue(0, (Real)((float)leaves.size() - 0.5f));
                VssTreeLeaf *leaf = leaves[index];

                AxisAlignedBox3 dirBox = tree->GetDirBBox(leaf);
                AxisAlignedBox3 box = tree->GetBBox(leaf);
                
                beam.Construct(box, dirBox);

                // collect kd leaves and view cells
                mKdTree->CastBeam(beam);
                vm->CastBeam(beam);

                Debug << "found " << (int)beam.mViewCells.size() << " view cells and " 
                          << (int)beam.mKdNodes.size() << " kd nodes" << endl;

                BeamSampleStatistics stats;

                // §§matt
                /*      
                renderer->SampleBeamContributions(sourceObj,
                                                                                  beam,
                                                                                  200000,
                                                                                  stats);

                char s[64]; sprintf(s, "shaft%04d.png", i);

                QImage image = renderer->toImage();
                image.save(s, "PNG");
                Debug << "beam statistics: " << stats << endl << endl;
                */

                if (1)
                {
                        AxisAlignedBox3 sbox = mSceneGraph->GetBox();
                        Vector3 bmin = sbox.Min() - 150.0f;
                        Vector3 bmax = sbox.Max() + 150.0f;
                        AxisAlignedBox3 vbox(bmin, bmax);
                
                        exporter->ExportBeam(beam, vbox);
                }

                const bool exportViewCells = false;

                if (exportViewCells)
                {
                        ViewCellContainer::const_iterator it, it_end = beam.mViewCells.end();
                        
                        for (it = beam.mViewCells.begin(); it != beam.mViewCells.end(); ++ it)
                        {
                                BspNodeGeometry geom;
                                AxisAlignedBox3 vbox;
                                vbox.Initialize();
                                vbox.Include((*it)->GetMesh());
                        
                                exporter->SetWireframe();
                                exporter->ExportBox(vbox);
                                exporter->SetFilled();
                                exporter->ExportViewCell(*it);
                        }
                }
        }
        
        delete exporter;
}


float
VssPreprocessor::GetAvgPvsSize(VssTree *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();
}

bool
VssPreprocessor::ComputeVisibility()
{
        Debug << "type: vss" << endl;

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

        if (!mLoadViewCells)
        {
                // generate new view cells from the scratch using coarse sampling
                ConstructViewCells();
        }
#if 0
        else 
        {        
                // load view cells from file
                // we test success by exporting view cells again
                VssRayContainer dummyContainer;
                mViewCellsManager->Visualize(mObjects, dummyContainer);
                
                mViewCellsManager->ExportViewCells("test.xml.zip", mViewCellsManager->GetExportPvs(), mObjects);
        }
#endif

        VssTree *vssTree = NULL; 
        const long initialTime = GetTime();

        if (mLoadInitialSamples)
        {
                cout << "Loading samples from file ... ";
                
                LoadSamples(mVssRays, mObjects);
                
                cout << "finished\n" << endl;
                totalSamples = (int)mVssRays.size();
        }
        else
        {
                while (totalSamples < mInitialSamples) 
                {
                        int passContributingSamples = 0;
                        int passSampleContributions = 0;
                        int passSamples = 0;

                        int index = 0;

                        int sampleContributions;

                        int s = Min(mSamplesPerPass, mInitialSamples);
                        for (int k=0; k < s; k++) 
                        {
                                Vector3 viewpoint; 

                                mViewCellsManager->GetViewPoint(viewpoint);
                                AxisAlignedBox3 vspBox = mViewCellsManager->GetViewSpaceBox();
                                const Vector3 direction = GetDirection(viewpoint, &vspBox);

                                const SimpleRay sray(viewpoint, direction,
                                                                         SamplingStrategy::DIRECTION_BOX_BASED_DISTRIBUTION,
                                                                         1.0f);
                                sampleContributions = mRayCaster->CastRay(sray,
                                                                                                                  mVssRays,
                                                                                                                  mViewCellsManager->GetViewSpaceBox(),
                                                                                                                  true);

                                if (sampleContributions) {
                                        passContributingSamples ++;
                                        passSampleContributions += sampleContributions;
                                }
                                passSamples++;
                                totalSamples++;
                        }

                        mPass++;
                        int pvsSize = 0;
                        float avgRayContrib = (passContributingSamples > 0) ?
                                passSampleContributions/(float)passContributingSamples : 0;

                        cout << "#Pass " << mPass << " : t = " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
                        cout << "#TotalSamples=" << totalSamples/1000
                                << "#SampleContributions=" << passSampleContributions << " ("
                                << 100*passContributingSamples/(float)passSamples<<"%)" << " avgPVS="
                                << pvsSize/(float)mObjects.size() << endl
                                << "avg ray contrib=" << avgRayContrib << endl;

                        mStats <<
                                "#Pass\n" <<mPass<<endl<<
                                "#Time\n" << TimeDiff(startTime, GetTime())*1e-3 << endl<<
                                "#TotalSamples\n" << totalSamples<< endl<<
                                "#SampleContributions\n" << passSampleContributions << endl <<
                                "#PContributingSamples\n"<<100*passContributingSamples/(float)passSamples<<endl <<
                                "#AvgPVS\n"<< pvsSize/(float)mObjects.size() << endl <<
                                "#AvgRayContrib\n" << avgRayContrib << endl;
                }
        }


        cout << "#totalRayStackSize=" << (int)mVssRays.size() << endl << flush;
        Debug << (int)mVssRays.size() << " rays generated in " 
                << TimeDiff(initialTime, GetTime()) * 1e-3 << " seconds" << endl;

        if (mStoreInitialSamples)
        {
                cout << "Writing " << (int)mVssRays.size() << " samples to file ... ";
                ExportSamples(mVssRays);
                cout << "finished\n" << endl;
        }


        //int numExportRays = 2000;
        int numExportRays = 0;

        if (numExportRays) {
                char filename[64];
                sprintf(filename, "vss-rays-initial.x3d");
                ExportRays(filename, mVssRays, numExportRays);
        }

        vssTree = new VssTree;
        // viewcells = Construct(mVssRays);

        vssTree->Construct(mVssRays, NULL);
        cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;

        if (0) ExportRays("kdtree.x3d", mVssRays, 10);

        if (0)
        {
                ExportVssTree("vss-tree-100.x3d", vssTree, Vector3(1,0,0));
                ExportVssTree("vss-tree-001.x3d", vssTree, Vector3(0,0,1));
                ExportVssTree("vss-tree-101.x3d", vssTree, Vector3(1,0,1));
                ExportVssTree("vss-tree-101m.x3d", vssTree, Vector3(-1,0,-1));
                ExportVssTreeLeaves(vssTree, 10);
        }

        // viewcells->UpdatePVS(newVssRays);
        // get viewcells as kd tree boxes
        vector<AxisAlignedBox3> kdViewcells;
        if (0) 
        {
                vector<KdLeaf *> leaves;
                mKdTree->CollectLeaves(leaves);
                vector<KdLeaf *>::const_iterator it;
                int targetLeaves = 50;
                float prob = targetLeaves/(float)leaves.size();
                for (it = leaves.begin(); it != leaves.end(); ++it)
                        if (RandomValue(0.0f,1.0f) < prob)
                                kdViewcells.push_back(mKdTree->GetBox(*it));

                float avgPvs = GetAvgPvsSize(vssTree, kdViewcells);
                cout<<"Initial average PVS size = "<<avgPvs<<endl;
        }


        int samples = 0;
        int pass = 0;


        // cast view cell samples
        while (samples < mVssSamples) 
        {
                int num = mVssSamplesPerPass;
                SimpleRayContainer rays;
                VssRayContainer vssRays;

                if (!mUseImportanceSampling) 
                {
                        for (int j=0; j < num; j++) {
                                Vector3 viewpoint; 
                                mViewCellsManager->GetViewPoint(viewpoint);
                                Vector3 direction = GetDirection(viewpoint, NULL);
                                rays.push_back(SimpleRay(viewpoint, direction,
                                                                                 SamplingStrategy::DIRECTION_BOX_BASED_DISTRIBUTION,
                                                                                 1.0f)
                                                           );
                        }
                } 
                else 
                {
                        num = GenerateImportanceRays(vssTree, num, rays);
                }

                CastRays(rays, vssRays, true);
                vssTree->AddRays(vssRays);

                if (0) 
                {
                        int subdivided = vssTree->UpdateSubdivision();
                        cout<<"subdivided leafs = "<<subdivided<<endl;
                }

                float avgPvs = GetAvgPvsSize(vssTree, kdViewcells);
                cout<<"Average PVS size = "<<avgPvs<<endl;

                /// compute view cell contribution of rays
                mViewCellsManager->ComputeSampleContributions(vssRays, true, false);

                if (numExportRays) {
                        char filename[64];
                        if (mUseImportanceSampling)
                                sprintf(filename, "vss-rays-i%04d.x3d", pass);
                        else
                                sprintf(filename, "vss-rays-%04d.x3d", pass);

                        ExportRays(filename, vssRays, numExportRays);
                }

                samples += num;

                float pvs = vssTree->GetAvgPvsSize();
                cout<<"*****************************\n";
                cout<<samples<<" avgPVS ="<<pvs<<endl;
                cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
                cout<<"*****************************\n";
                //      if (samples >= mVssSamples) break;
                pass ++;
        }

        if (mTestBeamSampling && mUseGlRenderer)
        {       
                TestBeamCasting(vssTree, mViewCellsManager, mObjects);
        }

        if (0)  Debug << vssTree->stat << endl;

        if (0)
        {
                VssRayContainer viewCellRays;
                // compute rays used for view cells construction
                const int numRays = mViewCellsManager->GetVisualizationSamples();
                vssTree->CollectRays(viewCellRays, numRays);
        }


        ////////////////////
        //-- render simulation after construction

        mRenderSimulator->RenderScene();
        SimulationStatistics ss;
        mRenderSimulator->GetStatistics(ss);
        Debug << "\nFinal view cells partition render time\n" << ss << endl;
        cout << "\nFinal view cells partition render time\n" << ss << endl;

        delete vssTree;

        return true;
}


void VssPreprocessor::DeterminePvsObjects(VssRayContainer &rays)
{
        // store higher order object
        mViewCellsManager->DeterminePvsObjects(rays, !mViewCellsManager->ViewCellsConstructed());
}


}