source: trunk/VUT/GtpVisibilityPreprocessor/src/VssPreprocessor.cpp @ 376

#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"

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

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

void
VssPreprocessor::SetupRay(Ray &ray, 
                                                                                                        const Vector3 &point, 
                                                                                                        const Vector3 &direction
                                                                                                        )
{
  ray.intersections.clear();
        // do not store anything else then intersections at the ray
  ray.Init(point, direction, Ray::LOCAL_RAY);
}

VssRay * 
VssPreprocessor::CastRay(
                                                                                                 Vector3 &viewPoint,
                                                                                                 Vector3 &direction
                                                                                                 )
{
        static Ray ray;
        AxisAlignedBox3 box = mKdTree->GetBox();
        
        SetupRay(ray, viewPoint, direction);
        // cast ray to KD tree to find intersection with other objects
        Intersectable *objectA, *objectB;
        Vector3 pointA, pointB;

        if (mKdTree->CastRay(ray)) {
                objectA = ray.intersections[0].mObject;
                pointA = ray.Extrap(ray.intersections[0].mT);
        } else {
                objectA = NULL;
                // compute intersection with the scene bounding box
                float tmin, tmax;
                box.ComputeMinMaxT(ray, &tmin, &tmax);
                pointA = ray.Extrap(tmax);
        }
        
        SetupRay(ray, viewPoint, -direction);
        
        if (mKdTree->CastRay(ray)) {
                objectB = ray.intersections[0].mObject;
          pointB = ray.Extrap(ray.intersections[0].mT);
        } else {
                objectB = NULL;
                float tmin, tmax;
                box.ComputeMinMaxT(ray, &tmin, &tmax);
                pointB = ray.Extrap(tmax);
        }

        VssRay *vssRay  = NULL;
        
        if (objectA || objectB) {
                vssRay = new VssRay(pointA,
                                                                                                pointB,
                                                                                                objectA,
                                                                                                objectB);
        }
        
        return vssRay;
}


Vector3
VssPreprocessor::GetViewpoint()
{
        AxisAlignedBox3 box = mKdTree->GetBox();

        // shrink the box in the y direction
        Vector3 diff(0, -box.Size().y*0.4f, 0);
        box.Enlarge(diff);
        
        return box.GetRandomPoint();
}

Vector3
VssPreprocessor::GetDirection(const Vector3 &viewpoint)
{
        int i = RandomValue(0, mObjects.size());
        Intersectable *object = mObjects[i];
        Vector3 point, normal;
        object->GetRandomSurfacePoint(point, normal);
        return point - viewpoint;
}



bool
VssPreprocessor::ComputeVisibility()
{
  
  mSceneGraph->CollectObjects(&mObjects);
        

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


  while (totalSamples < mTotalSamples) {
                int passContributingSamples = 0;
                int passSampleContributions = 0;
                int passSamples = 0;
                int index = 0;
                
                int sampleContributions;
                
                
                for (int k=0; k < mSamplesPerPass; k++) {

                        Vector3 viewpoint = GetViewpoint();
                        Vector3 direction = GetDirection(viewpoint);

                        VssRay *vssRay = CastRay(viewpoint, direction);
                        
                        if (vssRay) {
                                sampleContributions = vssRay->HitCount();
                                mVssRays.push_back(vssRay);
                        }
                        
                        //-- CORR matt: put block inside loop
                        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 
                                 << "k   #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 << "#totalPvsSize=" << mKdTree->CollectLeafPvs() << endl;
        cout << "#totalRayStackSize=" << mVssRays.size() << endl;

  return true;
}