source: GTP/trunk/Lib/Vis/Preprocessing/src/SamplingStrategy.cpp @ 1769

#include "SamplingStrategy.h"
#include "Ray.h"
#include "Intersectable.h"
#include "Preprocessor.h"
#include "ViewCellsManager.h"
#include "AxisAlignedBox3.h"


namespace GtpVisibilityPreprocessor {


SamplingStrategy::SamplingStrategy(const Preprocessor &preprocessor): 
mPreprocessor(preprocessor)
{
}


SamplingStrategy::~SamplingStrategy() 
{
}



/*********************************************************************/
/*            Individual sampling strategies implementation          */
/*********************************************************************/


bool ObjectBasedDistribution::GenerateSample(SimpleRay &ray) const
{
        Vector3 origin, direction; 

        mPreprocessor.mViewCellsManager->GetViewPoint(origin);

        Vector3 point;
        Vector3 normal;
        //cout << "y";
        const int i = (int)RandomValue(0, (float)mPreprocessor.mObjects.size() - 0.5f);

        Intersectable *object = mPreprocessor.mObjects[i];

        object->GetRandomSurfacePoint(point, normal);
        direction = point - origin;

        // $$ jb the pdf is yet not correct for all sampling methods!
        const float c = Magnitude(direction);

        if (c <= Limits::Small) 
                return false;

        // $$ jb the pdf is yet not correct for all sampling methods!
        const float pdf = 1.0f;
        
        direction *= 1.0f / c;
        ray = SimpleRay(origin, direction, pdf);

        return true;
}


bool ObjectDirectionBasedDistribution::GenerateSample(SimpleRay &ray) const
{       
        Vector3 origin, direction; 
    const int i = (int)RandomValue(0, (Real)mPreprocessor.mObjects.size() - 0.5f);
        Intersectable *object = mPreprocessor.mObjects[i];
        
        Vector3 normal;
        //cout << "x";
        object->GetRandomSurfacePoint(origin, normal);
        direction = UniformRandomVector(normal);
        
        origin += 0.1f * direction;

        const float c = Magnitude(direction);

        if (c <= Limits::Small) 
                return false;
        
        // $$ jb the pdf is yet not correct for all sampling methods!
        const float pdf = 1.0f;
        
        direction *= 1.0f / c;
        ray = SimpleRay(origin, direction, pdf);

        return true;
}


bool DirectionBasedDistribution::GenerateSample(SimpleRay &ray) const
{       
        Vector3 origin, direction; 
        mPreprocessor.mViewCellsManager->GetViewPoint(origin);
         
        direction = UniformRandomVector();
        const float c = Magnitude(direction);

        if (c <= Limits::Small) 
                return false;

        const float pdf = 1.0f;

        direction *= 1.0f / c;
        ray = SimpleRay(origin, direction, pdf);

        return true;
}


bool DirectionBoxBasedDistribution::GenerateSample(SimpleRay &ray) const
{
        Vector3 origin, direction; 
        mPreprocessor.mViewCellsManager->GetViewPoint(origin);

        const float alpha = RandomValue(0.0f, 2.0f * (float)M_PI);
        const float beta = RandomValue((float)-M_PI * 0.5f, (float)M_PI * 0.5f);
        
        direction = VssRay::GetDirection(alpha, beta);
        
        const float c = Magnitude(direction);

        if (c <= Limits::Small) 
                return false;

        const float pdf = 1.0f;

        direction *= 1.0f / c;
        ray = SimpleRay(origin, direction, pdf);

        return true;
}


bool SpatialBoxBasedDistribution::GenerateSample(SimpleRay &ray) const
{
        Vector3 origin, direction; 

        mPreprocessor.mViewCellsManager->GetViewPoint(origin);
        direction = mPreprocessor.mKdTree->GetBox().GetRandomPoint() - origin;
        //cout << "z";
        const float c = Magnitude(direction);

        if (c <= Limits::Small) 
                return false;

        const float pdf = 1.0f;

        direction *= 1.0f / c;
        ray = SimpleRay(origin, direction, pdf);

        return true;
}


bool ReverseObjectBasedDistribution::GenerateSample(SimpleRay &ray) const
{
        Vector3 origin, direction; 

        mPreprocessor.mViewCellsManager->GetViewPoint(origin);

        Vector3 point;
        Vector3 normal;
        //cout << "y";
        const int i = (int)RandomValue(0, (float)mPreprocessor.mObjects.size() - 0.5f);

        Intersectable *object = mPreprocessor.mObjects[i];

        object->GetRandomSurfacePoint(point, normal);
        
        direction = origin - point;
        
        // $$ jb the pdf is yet not correct for all sampling methods!
        const float c = Magnitude(direction);
        
        if ((c <= Limits::Small) || (DotProd(direction, normal) < 0))
        {
                return false;
        }

        // $$ jb the pdf is yet not correct for all sampling methods!
        const float pdf = 1.0f;
        //cout << "p: " << point << " ";
        direction *= 1.0f / c;
        // a little offset
        point += direction * 0.01f;

        ray = SimpleRay(point, direction, pdf);
        
        return true;
}


bool ViewCellBorderBasedDistribution::GenerateSample(SimpleRay &ray) const
{
        Vector3 origin, direction; 

        ViewCellContainer &viewCells = mPreprocessor.mViewCellsManager->GetViewCells();

        Vector3 point;
        Vector3 normal, normal2;
        
        const int vcIdx = (int)RandomValue(0, (float)viewCells.size() - 0.5f);
        const int objIdx = (int)RandomValue(0, (float)mPreprocessor.mObjects.size() - 0.5f);

        Intersectable *object = mPreprocessor.mObjects[objIdx];
        ViewCell *viewCell = viewCells[vcIdx];

        //cout << "vc: " << vcIdx << endl;
        //cout << "obj: " << objIdx << endl;

        object->GetRandomSurfacePoint(point, normal);
        viewCell->GetRandomEdgePoint(origin, normal2);

        direction = point - origin;

        // $$ jb the pdf is yet not correct for all sampling methods!
        const float c = Magnitude(direction);

        if ((c <= Limits::Small) /*|| (DotProd(direction, normal) < 0)*/)
        {
                return false;
        }

        // $$ jb the pdf is yet not correct for all sampling methods!
        const float pdf = 1.0f;
        //cout << "p: " << point << " ";
        direction *= 1.0f / c;
        ray = SimpleRay(origin, direction, pdf);

        //cout << "ray: " << ray.mOrigin << " " << ray.mDirection << endl;

        return true;
}


#if 0
bool ObjectsInteriorDistribution::GenerateSample(SimpleRay &ray) const
{
        Vector3 origin, direction; 

        // get random object
        const int i = RandomValue(0, mPreprocessor.mObjects.size() - 1);

        const Intersectable *obj = mPreprocessor.mObjects[i];

        // note: if we load the polygons as meshes, 
        // asymtotically every second sample is lost!
        origin = obj->GetBox().GetRandomPoint();

        // uniformly distributed direction
        direction = UniformRandomVector();

        const float c = Magnitude(direction);

        if (c <= Limits::Small) 
                return false;

        const float pdf = 1.0f;

        direction *= 1.0f / c;
        ray = SimpleRay(origin, direction, pdf);

        return true;
}

#endif
}