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

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

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;
        float bsize = Magnitude(box.Size());
        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);
                if (tmax > bsize) {
                        cerr<<"Warning: tmax > box size tmax="<<tmax<<" tmin="<<tmin<<" size="<<bsize<<endl;
                        cerr<<"ray"<<ray<<endl;
                }
                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);
                if (tmax > bsize) {
                        cerr<<"Warning: tmax > box size tmax="<<tmax<<" tmin="<<tmin<<" size="<<bsize<<endl;
                        cerr<<"ray"<<ray<<endl;
                }
                
                pointB = ray.Extrap(tmax);
        }

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


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)
{
        int i = RandomValue(0, mObjects.size()-1);
        Intersectable *object = mObjects[i];
        Vector3 point, normal;
        object->GetRandomSurfacePoint(point, normal);
        return point - viewpoint;
}



bool
VssPreprocessor::ComputeVisibility()
{
  
  mSceneGraph->CollectObjects(&mObjects);
        cout<<"#NUM_OBJECTS (Total numner of objects)\n"<<mObjects.size()<<endl;
        
  long startTime = GetTime();
  
  int i;
  int totalSamples = 0;

        AxisAlignedBox3 *viewSpaceBox = NULL;

        AxisAlignedBox3 box = mKdTree->GetBox();
        box.Enlarge(box.Size()*-Vector3(0.45, 0.45, 0.45));

        bool useViewSpaceBox = false;
        if (useViewSpaceBox)
                viewSpaceBox = &box;
        
  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(viewSpaceBox);
                        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 <<flush;

        VssTree *vssTree = new VssTree;

        vssTree->Construct(mVssRays, viewSpaceBox);
        
  return true;
}