source: GTP/trunk/Lib/Vis/Preprocessing/src/SamplingPreprocessor.cpp @ 1004

#include "SceneGraph.h"
#include "KdTree.h"
#include "SamplingPreprocessor.h"
#include "X3dExporter.h"
#include "Environment.h"
#include "MutualVisibility.h"
#include "Polygon3.h"
#include "ViewCell.h"
#include "ViewCellsManager.h"
#include "RenderSimulator.h"


namespace GtpVisibilityPreprocessor {


SamplingPreprocessor::SamplingPreprocessor(): mPass(0)
{
  // this should increase coherence of the samples
  Environment::GetSingleton()->GetIntValue("Sampling.samplesPerPass", mSamplesPerPass);
  Environment::GetSingleton()->GetIntValue("Sampling.totalSamples", mTotalSamples);
 
  mStats.open("stats.log");
}

SamplingPreprocessor::~SamplingPreprocessor()
{
        CLEAR_CONTAINER(mSampleRays);
        CLEAR_CONTAINER(mVssSampleRays);
}

void
SamplingPreprocessor::SetupRay(Ray &ray, 
                                                           const Vector3 &point, 
                                                           const Vector3 &direction,
                                                           const int type,
                                                           const Ray::Intersection &origin)
{
  ray.Clear();
  
        ray.mFlags |= Ray::STORE_KDLEAVES | Ray::STORE_BSP_INTERSECTIONS;
        //  cout<<point<<" "<<direction<<endl;

        ray.Init(point, direction, type);
        ray.sourceObject = origin;
}

void
SamplingPreprocessor::HoleSamplingPass()
{
  vector<KdLeaf *> leaves;
  mKdTree->CollectLeaves(leaves);
  
  // go through all the leaves and evaluate their passing contribution
  for (int i=0 ; i < leaves.size(); i++) {
    KdLeaf *leaf = leaves[i];
    cout<<leaf->mPassingRays<<endl;
  }
}

 
void
SamplingPreprocessor::CastRays(const RayContainer &rays)
{       
  // cast ray to KD tree to find intersection with other objects
  RayContainer::const_iterator it, it_end = rays.end();

  VssRayContainer vssRays;
  for (it = rays.begin(); it != it_end; ++it) {
        mKdTree->CastRay(*(*it));
        vssRays.push_back(new VssRay(*(*it)));
  }
  
  mViewCellsManager->ComputeSampleContributions(vssRays, true, false);
  CLEAR_CONTAINER(vssRays);
}

int
SamplingPreprocessor::CastRay(Ray &ray)
{
        // cast ray to KD tree to find intersection with other objects
        mKdTree->CastRay(ray);
        VssRay vssRay(ray);

        mViewCellsManager->ComputeSampleContributions(vssRay, true, false);
        
        return vssRay.mPvsContribution;
}

//  void
//  SamplingPreprocessor::AvsGenerateRandomRay(Ray &ray)
//  {
//    int objId = RandomValue(0, mObjects.size());
//    Intersectable *object = objects[objId];
//    object->GetRandomSurfacePoint(point, normal);
//    direction = UniformRandomVector(normal);
//    SetupRay(ray, point, direction);
//  }

//  void
//  SamplingPreprocessor::AvsHandleRay(Ray &ray)
//  {
//    int sampleContributions = 0;

//    mKdTree->CastRay(ray);
  
//    if (ray.leaves.size()) {
//      sampleContributions += AddNodeSamples(object, ray, pass);
    
//      if (ray.intersections.size()) {
//        sampleContributions += AddNodeSamples(ray.intersections[0].mObject, ray, pass);
//      }
//    }
//  }

//  void
//  SamplingPreprocessor::AvsBorderSampling(Ray &ray)
//  {
  

//  }

//  void
//  SamplingPreprocessor::AvsPass()
//  {
//    Ray ray;
//    while (1) {
//      AvsGenerateRay(ray);
//      HandleRay(ray);
//      while ( !mRayQueue.empty() ) {
//        Ray ray = mRayQueue.pop();
//        mRayQueue.pop();
//        AdaptiveBorderSampling(ray);
//      }
//    }
  
  

//  }


int
SamplingPreprocessor::CastEdgeSamples(
                                                                          Intersectable *object,
                                                                          const Vector3 &point,
                                                                          MeshInstance *mi,
                                                                          const int samples
                                                                          )
{
        Ray ray;
        int maxTries = samples*10;
        int i;
        int rays = 0;
        int edgeSamplesContributions = 0;
        for (i=0; i < maxTries && rays < samples; i++) {
                // pickup a random face of each mesh 
                Mesh *mesh = mi->GetMesh();
                int face = (int)RandomValue(0, (Real)((int)mesh->mFaces.size() - 1));
                
                Polygon3 poly(mesh->mFaces[face], mesh);
                poly.Scale(1.001f);
                // now extend a random edge of the face
                int edge = (int)RandomValue(0, (Real)((int)poly.mVertices.size() - 1));
                float t = RandomValue(0.0f, 1.0f);
                Vector3 target = t*poly.mVertices[edge] + (1.0f-t)*poly.mVertices[(edge + 1)%
                        poly.mVertices.size()];
                SetupRay(ray, point, target - point, Ray::LOCAL_RAY, Ray::Intersection(0, object, 0));
                if (!mesh->CastRay(ray, mi)) {
                        // the rays which intersect the mesh have been discarded since they are not tangent
                        // to the mesh
                        rays++;
                        edgeSamplesContributions += CastRay(ray);
                }
        }
        return edgeSamplesContributions;
}

KdNode *
SamplingPreprocessor::GetNodeToSample(Intersectable *object)
{
        int pvsSize = object->mKdPvs.GetSize();
        KdNode *nodeToSample = NULL;
        
        bool samplePvsBoundary = false;
        if (pvsSize && samplePvsBoundary) {
                // this samples the nodes from the boundary of the current PVS
                // mail all nodes from the pvs
                Intersectable::NewMail();
                KdPvsMap::iterator i = object->mKdPvs.mEntries.begin();
                
                for (; i != object->mKdPvs.mEntries.end(); i++) {
                        KdNode *node = (*i).first;
                        node->Mail();
                }
                
                int maxTries = 2*pvsSize;
                Debug << "Finding random neighbour" << endl;    
                for (int tries = 0; tries < 10; tries++) {
                        int index = (int)RandomValue(0, (Real)(pvsSize - 1));
                        KdPvsData data;
                        KdNode *node;
                        object->mKdPvs.GetData(index, node, data);
                        nodeToSample = mKdTree->FindRandomNeighbor(node, true);
                        if (nodeToSample)
                                break;
                }
        } else {
                // just pickup a random node
                //              nodeToSample = mKdTree->GetRandomLeaf(Plane3(normal, point));
                nodeToSample = mKdTree->GetRandomLeaf();
        }
        return nodeToSample;
}

void
SamplingPreprocessor::VerifyVisibility(Intersectable *object)
{
        // mail all nodes from the pvs
        Intersectable::NewMail();
        KdPvsMap::iterator i = object->mKdPvs.mEntries.begin();
        for (; i != object->mKdPvs.mEntries.end(); i++) {
                KdNode *node = (*i).first;
                node->Mail();
        }
        Debug << "Get all neighbours from PVS" << endl;
        vector<KdNode *> invisibleNeighbors;
        // get all neighbors of all PVS nodes
        i = object->mKdPvs.mEntries.begin();
        for (; i != object->mKdPvs.mEntries.end(); i++) {
                KdNode *node = (*i).first;
                mKdTree->FindNeighbors(node, invisibleNeighbors, true);
                AxisAlignedBox3 box = object->GetBox();
                for (int j=0; j < invisibleNeighbors.size(); j++) {
                        int visibility = ComputeBoxVisibility(mSceneGraph,
                                                              mKdTree,
                                                              box,
                                                              mKdTree->GetBox(invisibleNeighbors[j]),
                                                              1e-6f);
                        //            exit(0);
                }
                // now rank all the neighbors according to probability that a new
                // sample creates some contribution
        }
}

bool
SamplingPreprocessor::ComputeVisibility()
{
  
  /// rays per pass
  RayContainer passRays;


  mViewCellsManager->SetViewSpaceBox(mKdTree->GetBox());
  
  Vector3 point, normal, direction;
  //Ray ray;

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

  int pvsSize = 0;

  while (totalSamples < mTotalSamples) {
                int passContributingSamples = 0;
                int passSampleContributions = 0;
                int passSamples = 0;
                int index = 0;
                
                int reverseSamples = 0;
                
                for (i = 0; i < mObjects.size(); i++) {
                                                
                        KdNode *nodeToSample = NULL;
                        Intersectable *object = mObjects[i];
                
                        int pvsSize = 0;
                        
                        if (0 && pvsSize && mPass == 1000 ) {
                                VerifyVisibility(object);
                        }
                        
                        int faceIndex = object->GetRandomSurfacePoint(point, normal);
                        
                        bool viewcellSample = true;
                        //int sampleContributions;
                        bool debug = false; //(object->GetId() >= 2199);
                        if (viewcellSample) {
                                //mKdTree->GetRandomLeaf(Plane3(normal, point));

                                nodeToSample = GetNodeToSample(object);

                                for (int k=0; k < mSamplesPerPass; k++) {
                                        bool reverseSample = false;
                                
                                        if (nodeToSample) {
                                                AxisAlignedBox3 box = mKdTree->GetBox(nodeToSample);
                                                Vector3 pointToSample = box.GetRandomPoint();
                                                //                                              pointToSample.y = 0.9*box.Min().y + 0.1*box.Max().y;
                                                if (object->GetRandomVisibleSurfacePoint( point, normal, pointToSample, 3 )) {
                                                        direction = pointToSample - point;
                                                } else {
                                                        reverseSamples++;
                                                        reverseSample = true;
                                                        direction = point - pointToSample;
                                                        point = pointToSample;
                                                        //Debug << "point: " << pointToSample << endl;
                                                }
                                        }
                                        else {
                                                direction = UniformRandomVector(normal);
                                        }
                                        
                                        Ray *ray = new Ray();

                                        // construct a ray
                                        SetupRay(*ray, point, direction, Ray::LOCAL_RAY, 
                                                         Ray::Intersection(0, reverseSample ? NULL : object, faceIndex));

                                        passRays.push_back(ray);
                                        
                                        //-- CORR matt: put block inside loop
                                        /*if (sampleContributions) {
                                                passContributingSamples ++;
                                                passSampleContributions += sampleContributions;
                                        }*/
                                }
                        } else {
                                // edge samples
                                // get random visible mesh
                                //                              object->GetRandomVisibleMesh(Plane3(normal, point));
                        }
        
                        // CORR matt: must add all samples
                        passSamples += mSamplesPerPass;
                }
        
                //-------------------
                // cast rays for view cells construction
                ProcessViewCells(passRays,
                                                 mObjects,
                                                 passSampleContributions,
                                                 passContributingSamples);

                CLEAR_CONTAINER(passRays);
                
                totalSamples += passSamples; 
                
                //    if (pass>10)
                //      HoleSamplingPass();
    
                mPass ++;
        
                pvsSize += passSampleContributions;
                
                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<<"%)" << " avgPVS="
                                 << (float)pvsSize /(float)mObjects.size() << endl 
                                 << "avg ray contrib=" << avgRayContrib << endl
                                 << "reverse samples [%]" << reverseSamples/(float)passSamples*100.0f << 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 << "#totalKdPvsSize=" << mKdTree->CollectLeafPvs() << endl;
        
  //  HoleSamplingPass();
        if (0) {
                Exporter *exporter = Exporter::GetExporter("ray-density.x3d"); 
                exporter->SetExportRayDensity(true);
                exporter->ExportKdTree(*mKdTree);
                delete exporter;
        }
        
        // construct view cells if not already constructed
        if (!mViewCellsManager->ViewCellsConstructed())
          mViewCellsManager->ConstructSubdivision(mObjects, mVssSampleRays);

        // $$JB temporary removed
        //      mViewCellsManager->PostProcess(objects, mSampleRays);
        
        //-- several visualizations and statistics
        Debug << "view cells after post processing: " << endl;
        mViewCellsManager->PrintStatistics(Debug);

        //-- 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;
        
        // $$JB temporary removed
        //mViewCellsManager->Visualize(objects, mSampleRays);   
   
        return true;
}

void SamplingPreprocessor::ProcessViewCells(const RayContainer &newRays,
                                                                                        const ObjectContainer &objects,
                                                                                        int &sampleContributions,
                                                                                        int &contributingSamples)
{
  // cast rays to view cells
  CastRays(newRays);

  // save rays for view cells construction
  if (!mViewCellsManager->ViewCellsConstructed())
        {
          if ((int)mVssSampleRays.size() < mViewCellsManager->GetConstructionSamples())
                {
                  RayContainer::const_iterator it, it_end = newRays.end();
                  
                  for (it = newRays.begin(); it != it_end; ++ it)
                        mVssSampleRays.push_back(new VssRay(*(*it)));
                }
          else
                {
                  // construct view cells
                  mViewCellsManager->ConstructSubdivision(objects, mVssSampleRays);
                  
                  // throw away samples 
                  //CLEAR_CONTAINER(mVssSampleRays);
                }
        }
  // Need rays (with ordered intersections) for post processing => collect new rays
  if (((int)mSampleRays.size() < mViewCellsManager->GetPostProcessSamples()) ||
          ((int)mSampleRays.size() < mViewCellsManager->GetVisualizationSamples()))
        {
          RayContainer::const_iterator it, it_end = newRays.end();
          
          for (it = newRays.begin(); it != it_end; ++ it)
                mSampleRays.push_back(new Ray(*(*it)));
        }
}

}