source: trunk/VUT/GtpVisibilityPreprocessor/src/SamplingPreprocessor.cpp @ 179

#include "SceneGraph.h"
#include "KdTree.h"
#include "SamplingPreprocessor.h"
#include "X3dExporter.h"
#include "Environment.h"
SamplingPreprocessor::SamplingPreprocessor()
{
  // this should increase coherence of the samples
  environment->GetIntValue("Sampling.samplesPerPass", mSamplesPerPass);
  environment->GetIntValue("Sampling.totalSamples", mTotalSamples);
  mKdPvsDepth = 100;

}

void
SamplingPreprocessor::SetupRay(Ray &ray, const Vector3 &point, const Vector3 &direction)
{
  ray.intersections.clear();
  ray.leaves.clear();
  ray.meshes.clear();
  //  cout<<point<<" "<<direction<<endl;
  ray.Init(point, direction, Ray::LOCAL_RAY);
}

KdNode *
SamplingPreprocessor::GetNodeForPvs(KdLeaf *leaf)
{
  KdNode *node = leaf;
  while (node->mParent && node->mDepth > mKdPvsDepth)
    node = node->mParent;
  return node;
}

int
SamplingPreprocessor::AddNodeSamples(Intersectable *object, const Ray &ray)
{
  int contributingSamples = 0;

  for (int j=0; j < ray.leaves.size(); j++) {
    KdNode *node = GetNodeForPvs( ray.leaves[j] );
    contributingSamples += object->mKdPvs.AddNodeSample(node);
  }
  
  return contributingSamples;
}

bool
SamplingPreprocessor::ComputeVisibility()
{

  // pickup an object
  ObjectContainer objects;
  
  mSceneGraph->CollectObjects(&objects);

  Vector3 point, normal, direction;
  Ray ray;

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


  int pvsOut = Min((int)objects.size(), 10);
  
  vector<Ray> rays[10];
  
  while (totalSamples < mTotalSamples) {

    int passContributingSamples = 0;
    int passSampleContributions = 0;
    int passSamples = 0;
        int index = 0;
    KdNode *visibleNode = NULL;

    for (i =0; i < objects.size(); i++) {
      KdNode *nodeToSample = NULL;
      Intersectable *object = objects[i];

      int pvsSize = object->mKdPvs.GetSize();
      
    if (0 && pvsSize) {
                // 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;
        
                for (int tries = 0; tries < 10; tries++) {
                        index = RandomValue(0, pvsSize - 1);
                        KdPvsData data;
                        object->mKdPvs.GetData(index, visibleNode, data);
                        nodeToSample = mKdTree->FindRandomNeighbor(visibleNode, true);
                        if (nodeToSample)
                        break;
                }
        }

    if (pvsSize) {
                // 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();
                }
        
                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(visibleNode, invisibleNeighbors, true);
                }

                KdPvsData data;
                KdNode *visibleNode;
                object->mKdPvs.GetData(index, visibleNode, data);
                nodeToSample = mKdTree->FindRandomNeighbor(visibleNode, true);
                if (nodeToSample)
                        break;
      }
      

      for (int k=0; k < mSamplesPerPass; k++) {
                  object->GetRandomSurfacePoint(point, normal);
                  if (nodeToSample) {
                          int maxTries = 5;
                          for (int tries = 0; tries < maxTries; tries++) {
                                  direction = mKdTree->GetBox(nodeToSample).GetRandomPoint() - point;
                                  if (DotProd(direction, normal) > Limits::Small)
                                        break;
                          }
                
                          if (tries == maxTries)
                                  direction = UniformRandomVector(normal);
                  } else
                          direction = UniformRandomVector(normal);
        
                  // construct a ray
                  SetupRay(ray, point, direction);
                  mKdTree->CastRay(ray);

                  if (i < pvsOut)
                          rays[i].push_back(ray);
        
                  int sampleContributions = 0;
        
                  
                  if (ray.leaves.size()) {
                          sampleContributions += AddNodeSamples(object, ray);
          
                          if (ray.intersections.size()) {
                                  sampleContributions += AddNodeSamples(ray.intersections[0].mObject, ray);
                                  // check whether we can add this to the rays
                                  for (int j = 0; j < pvsOut; j++) {
                                          if (objects[j] == ray.intersections[0].mObject) {
                                                  rays[j].push_back(ray);
                                          }
                                  }
                          }
                
                          passSamples++;
                        
                          if (sampleContributions) {
                                  passContributingSamples++;
                                  passSampleContributions += sampleContributions;
                          }
                  }
          }
        }
    totalSamples += passSamples;
    pass++;
    
    int pvsSize = 0;
    for (i=0; i < objects.size(); i++) {
      Intersectable *object = objects[i];
      pvsSize += object->mKdPvs.GetSize();
    }
    
    cout<<"pass "<<pass<<" : t = "<<TimeDiff(startTime, GetTime())*1e-3<<"s"<<endl;
    cout<<"#totalSamples="<<totalSamples/1000<<
      "k   #sampleContributions="<<passSampleContributions<<
      " ("<<100*passContributingSamples/(float)passSamples<<"%)"<<
      " avgPVS="<<pvsSize/(float)objects.size()<<endl<<
      "avg ray contrib="<<passSampleContributions/(float)passContributingSamples<<
      endl;
  }
  bool exportRays = false;
  if (exportRays) {
    Exporter *exporter = NULL;
    exporter = Exporter::GetExporter("sample-rays.x3d");
    exporter->SetWireframe();
    exporter->ExportKdTree(*mKdTree);
    for (i=0; i < pvsOut; i++) 
      exporter->ExportRays(rays[i], 1000, RgbColor(1, 0, 0));
    exporter->SetFilled();
    delete exporter;
  }

  if (1) {
    for (int k=0; k < pvsOut; k++) {
      Intersectable *object = objects[k];
      char s[64];
      sprintf(s, "sample-pvs%04d.x3d", k);
      Exporter *exporter = Exporter::GetExporter(s);
      exporter->SetWireframe();
      KdPvsMap::iterator i = object->mKdPvs.mEntries.begin();
      Intersectable::NewMail();
        // avoid adding the object to the list
      object->Mail();
      ObjectContainer visibleObjects;
      for (; i != object->mKdPvs.mEntries.end(); i++) {
        KdNode *node = (*i).first;
        exporter->ExportBox(mKdTree->GetBox(node));
        mKdTree->CollectObjects(node, visibleObjects);
      }
      
      exporter->ExportRays(rays[k], 1000, RgbColor(0, 1, 0));
      exporter->SetFilled();

      for (int j = 0; j < visibleObjects.size(); j++)
        exporter->ExportIntersectable(visibleObjects[j]);
        
      Material m;
      m.mDiffuseColor = RgbColor(1, 0, 0);
      exporter->SetForcedMaterial(m);
      exporter->ExportIntersectable(object);
      
      delete exporter;
    }
    
  }
  
  return true;
}