source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/SampleGenerator.cpp @ 2955

#include "SampleGenerator.h"
#include "common.h"


using namespace std;
using namespace CHCDemoEngine;

HaltonSequence SphericalSampleGenerator3::sHalton;
HaltonSequence PoissonDiscSampleGenerator2::sHalton;
HaltonSequence RandomSampleGenerator2::sHalton;
HaltonSequence QuadraticDiscSampleGenerator2::sHalton;


SampleGenerator::SampleGenerator(int numSamples, float radius):
mNumSamples(numSamples), mRadius(radius)
{}


PoissonDiscSampleGenerator2::PoissonDiscSampleGenerator2(int numSamples, float radius):
SampleGenerator(numSamples, radius)
{}


void PoissonDiscSampleGenerator2::Generate(float *samples) const
{
        // this is a hacky poisson sampling generator which does random dart-throwing on a disc.
        // as a savety criterium, the min distance requirement is relaxed if we are not 
        // able to place any dart for a number of tries
        // the solution is a possion sampling with respect to the adjusted min distance
        // better solutions have been proposed, i.e., using hierarchical sampling
        const float maxTries = 1000;
        const float f_reduction = 0.9f;

        //static HaltonSequence halton;
        float r[2];

        // generates poisson distribution on disc
        // start with some threshold. best case: all samples lie on the circumference
        //const float minDist = 2.0f * mRadius / sqrt((float)mNumSamples);
        const float eps = 0.2f;
        const float minDist = 2.0f * mRadius * M_PI * (1.0f - eps) / (float)mNumSamples;
        float sqrMinDist = minDist * minDist;

        //cout << "minDist before= " << minDist << endl;
        Sample2 *s = (Sample2 *)samples;

        int totalTries = 0;

        // check if on disc
        for (int i = 0; i < mNumSamples; ++ i)
        {
                int tries = 0;

                // repeat until valid sample was found
                while (1)
                {
                        ++ tries;
                        ++ totalTries;

                        // note: should use halton, but seems somewhat broken
                        //r[0] = RandomValue(.0f, mRadius);
                        //r[1] = RandomValue(.0f, mRadius);
                        sHalton.GetNext(2, r);

                        // scale to -1 .. 1
                        const float rx = r[0] * 2.0f - 1.0f;
                        const float ry = r[1] * 2.0f - 1.0f;

                        // check if in disk, else exit early
                        if (rx * rx + ry * ry > mRadius * mRadius)
                                continue;

                        bool sampleValid = true;

                        // check poisson property
                        for (int j = 0; ((j < i) && sampleValid); ++ j)
                        {
                                const float dist = 
                                        (s[j].x - rx) * (s[j].x - rx) +
                                        (s[j].y - ry) * (s[j].y - ry);
                        
                                if (dist < sqrMinDist)
                                        sampleValid = false;
                        }

                        if (sampleValid)
                        {
                                s[i].x = rx;
                                s[i].y = ry;
                                break;
                        }

                        if (tries > maxTries)
                        {
                                sqrMinDist *= f_reduction;
                                tries = 0;
                        }
                }
        }

        //cout << "minDist after= " << sqrt(sqrMinDist) << " #tries: " << totalTries << endl;
}


RandomSampleGenerator2::RandomSampleGenerator2(int numSamples, float radius):
SampleGenerator(numSamples, radius)
{}


void RandomSampleGenerator2::Generate(float *samples) const
{
        Sample2 *s = (Sample2 *)samples;

        int numSamples = 0;

        float r[2];

        while (numSamples < mNumSamples)
        {
                //r[0] = RandomValue(-mRadius, mRadius);
                //r[1] = RandomValue(-mRadius, mRadius);
                sHalton.GetNext(2, r);
                
                const float rx = r[0] * 2.0f - 1.0f;
                const float ry = r[1] * 2.0f - 1.0f;

                // check if in disk, else exit early
                if (rx * rx + ry * ry > mRadius * mRadius)
                        continue;

                s[numSamples].x = rx;
                s[numSamples].y = ry;

                ++ numSamples;
        }
}


SphericalSampleGenerator3::SphericalSampleGenerator3(int numSamples, float radius):
SampleGenerator(numSamples, radius)
{}


void SphericalSampleGenerator3::Generate(float *samples) const
{
        float r[2];
        Sample3 *s = (Sample3 *)samples;

        for (int i = 0; i < mNumSamples; ++ i)
        {
                r[0] = RandomValue(0, 1);
                r[1] = RandomValue(0, 1);

                //sHalton.GetNext(2, r);

                // create stratified samples over sphere
                const float theta = 2.0f * acos(sqrt(1.0f - r[0]));
                const float phi = 2.0f * M_PI * r[1];
 
                s[i].x = mRadius * sin(theta) * cos(phi);
                s[i].y = mRadius * sin(theta) * sin(phi);
                s[i].z = mRadius * cos(theta);
        }
}


QuadraticDiscSampleGenerator2::QuadraticDiscSampleGenerator2(int numSamples, float radius):
SampleGenerator(numSamples, radius)
{}


void QuadraticDiscSampleGenerator2::Generate(float *samples) const
{
#if 0
        float r[2];
        Sample2 *s = (Sample2 *)samples;

        for (int i = 0; i < mNumSamples; ++ i)
        {
                //r[0] = samples[i * 2];
                //r[1] = samples[i * 2 + 1];
                sHalton.GetNext(2, r);

                // create samples over disc: the sample density
                // decreases quadratically with the distance to the origin
                s[i].x = mRadius * r[1] * sin(2.0f * M_PI * r[0]);
                s[i].y = mRadius * r[1] * cos(2.0f * M_PI * r[0]);
        }
#else

        PoissonDiscSampleGenerator2 poisson(mNumSamples, 1.0f);
        poisson.Generate(samples);

        Sample2 *s = (Sample2 *)samples;

        // multiply with lenght to get quadratic dependence on the distance
        for (int i = 0; i < mNumSamples; ++ i)
        {
                Sample2 &spl = s[i];

                float len = sqrt(spl.x * spl.x + spl.y * spl.y);
                spl.x *= len * mRadius;
                spl.y *= len * mRadius;
        }
#endif
}