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

#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);
}

int
VssPreprocessor::CastRay(
                                                                                                 Vector3 &viewPoint,
                                                                                                 Vector3 &direction
                                                                                                 )
{
        int hits = 0;
        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);
                
        }

        bool detectEmptyViewSpace = true;
        
        if (detectEmptyViewSpace) {
                SetupRay(ray, pointA, -direction);
        } else
                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;

        bool validSample = true;
        if (detectEmptyViewSpace) {
                if (Distance(pointA, pointB) <
                                Distance(viewPoint, pointA) + Distance(viewPoint, pointB) - Limits::Small) {
                        validSample = false;
                }
        }
        
        if (validSample) {
                if (objectA) {
                        vssRay = new VssRay(pointB,
                                                                                                        pointA,
                                                                                                        objectB,
                                                                                                        objectA);
                        mVssRays.push_back(vssRay);
                        hits ++;
                }
                
                if (objectB) {
                        vssRay = new VssRay(pointA,
                                                                                                        pointB,
                                                                                                        objectA,
                                                                                                        objectB);
                        mVssRays.push_back(vssRay);
                        hits ++;
                }
        }
        
        return hits;
}


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);
        
  long startTime = GetTime();
  
  int totalSamples = 0;

        AxisAlignedBox3 *viewSpaceBox = NULL;

        AxisAlignedBox3 box = mKdTree->GetBox();

        
        if (1)
                box.Enlarge(box.Size()*-Vector3(0.45, 0.45, 0.45));
        else {
                // sample city like heights
                box.SetMin(1, box.Min(1) + box.Size(1)*0.1);
                box.SetMax(1, box.Min(1) + box.Size(1)*0.2);
        }
        
        bool useViewSpaceBox = true;
        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);
                        
                        sampleContributions = CastRay(viewpoint, direction);
                        
                        
                        //-- 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;

        cout<<"Exporting vss rays..."<<endl<<flush;
        
        int exportRays = 10000;

        if (exportRays) {
                float prob = exportRays/(float)mVssRays.size();
                
                Exporter *exporter = NULL;
                exporter = Exporter::GetExporter("vss-rays.x3d");
                exporter->SetWireframe();
                exporter->ExportKdTree(*mKdTree);
                if (viewSpaceBox) {
                        exporter->SetForcedMaterial(RgbColor(1,0,0));
                        exporter->ExportBox(*viewSpaceBox);
                        exporter->ResetForcedMaterial();
                }
                VssRayContainer rays;
                for (int i=0; i < mVssRays.size(); i++)
                        if (RandomValue(0,1) < prob)
                                rays.push_back(mVssRays[i]);
                exporter->ExportRays(rays, RgbColor(1, 0, 0));

                delete exporter;
        }
        cout<<"done."<<endl<<flush;

        VssTree *vssTree = new VssTree;

        vssTree->Construct(mVssRays, viewSpaceBox);

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


  return true;
}