Eigene Dateien/FlowVis/src/VWhiteNoise.cpp

Go to the documentation of this file.

#include "VWhiteNoise.h"
#include "glew.h"
#include <time.h>
#include <iostream>
#include <cmath>

VWhiteNoise::VWhiteNoise() : mTextureHandle(0), mWidth(0), mHeight(0), mRandomNumberGenerator(1024), mFrolicHandle(0), mFWidth(0), mFHeight(0)
{
        int32 seed = (int32)time(0);        // random seed

        // choose one of the random number generators:
        mRandomNumberGenerator = TRandomCombined<CRandomMother, CRandomMersenne>(seed);           // make instance of random number generator
}

VWhiteNoise::~VWhiteNoise()
{
        if(mTextureHandle != 0)
        {
                glDeleteTextures(1, &mTextureHandle);
                mTextureHandle = 0;
        }
        mNoise.clear();

        if(mFrolicHandle != 0)
        {
                glDeleteTextures(1, &mFrolicHandle);
                mFrolicHandle = 0;
        }
        mFrolic.clear();
}

void VWhiteNoise::generate( int m_Width, int m_Height, int m_Steps /* = 20 */ )
{
        mWidth = m_Width;
        mHeight = m_Height;

        std::cout << "Generating White Noise of size " << m_Height << " x " << m_Height << std::endl;
        mNoise.clear();

        for(int i = 0; i < (m_Width * m_Height); ++i)
        {
                mNoise.push_back(generateRandom(m_Steps));
        }

        bindOpenGlTexture();
}

void VWhiteNoise::generateFrolicTexture ( int m_Width, int m_Height)
{
        mFWidth = m_Width;
        mFHeight = m_Height;
        mFrolic.clear();

        mFrolic.resize(mFWidth * mFHeight);

        for(int i = 0; i < (int)((float)(mFWidth * mFHeight) / 4.0f); ++i)
        {
                float x = generateRandom(20);
                float y = generateRandom(20);

                int xind = (int)(x * (float)mFWidth);
                int yind = (int)(y * (float)mFHeight);

                mFrolic[yind * mFWidth + xind] = 1.0f;
        }


        bindOpengGlFrolicTexture();
}

void VWhiteNoise::bindOpenGlTexture()
{
        std::vector<float> tmp;

        for(int i = 0; i < mWidth * mHeight; ++i)
        {
                tmp.push_back(mNoise[i]);
                tmp.push_back(mNoise[i]);
                tmp.push_back(mNoise[i]);
                tmp.push_back(1.0f);
        }

        if(mTextureHandle != 0)
        {
                glDeleteTextures(1, &mTextureHandle);
        }

        glEnable(GL_TEXTURE_2D);
        glGenTextures(1, &mTextureHandle);

        glBindTexture(GL_TEXTURE_2D, mTextureHandle);

        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

        gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA16F_ARB, mWidth, mHeight, GL_RGBA, GL_FLOAT, &(tmp[0]));
        //glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mWidth, mHeight, GL_RGBA, GL_FLOAT, &(tmp[0]));

        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);

        const GLenum glError = glGetError();

        if (glError != GL_NO_ERROR)
                std::cout << "Error Generating White Noise " << gluErrorString(glError) << std::endl;
        else
                std::cout << "Finished Generating White Noise." << std::endl;
}

void VWhiteNoise::bindOpengGlFrolicTexture()
{
        std::vector<float> tmp;

        for(int i = 0; i < mFWidth * mFHeight; ++i)
        {
                tmp.push_back(mFrolic[i]);
                tmp.push_back(mFrolic[i]);
                tmp.push_back(mFrolic[i]);
                tmp.push_back(1.0f);
        }

        if(mFrolicHandle != 0)
        {
                glDeleteTextures(1, &mFrolicHandle);
        }

        glEnable(GL_TEXTURE_2D);
        glGenTextures(1, &mFrolicHandle);

        glBindTexture(GL_TEXTURE_2D, mFrolicHandle);

        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

        gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA16F_ARB, mFWidth, mFHeight, GL_RGBA, GL_FLOAT, &(tmp[0]));
        //glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mWidth, mHeight, GL_RGBA, GL_FLOAT, &(tmp[0]));

        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);

        const GLenum glError = glGetError();

        if (glError != GL_NO_ERROR)
                std::cout << "Error Generating White Noise " << gluErrorString(glError) << std::endl;
        else
                std::cout << "Finished Generating White Noise." << std::endl;
}


float VWhiteNoise::generateRandom( int m_Steps )
{
        /*float x = 0.0f;
        for (int i = 0; i < m_Steps; ++i)
        {
                float u = mRandomNumberGenerator.Random();
                x += u;
        }               
        
        x -= (float) m_Steps / 2.0f;
        x *= sqrt(12.0f / (float)m_Steps);
        x = x / (float)m_Steps + 0.5f;
        */
        //float s = 100.0f;
        //float v1;
        //float v2;

        //while ( s >= 1.0f)
        //{
        //      float u1 = mRandomNumberGenerator.Random();
        //      float u2 = mRandomNumberGenerator.Random();
        //      v1 = 2.0f * u1 - 1.0f;
        //      v2 = 2.0f * u2 - 1.0f;
        //      s = v1 * v1 + v2 *  v2;
        //}
        //float X = sqrt(-2.0f * log(s) / s) * v1;
        //float Y = sqrt(-2.0f * log(s) / s) * v2;

        /*const static int q = 15;
        const static float c1 = (1 << q) - 1;
        const static float c2 = ((int)(c1 / 3)) + 1;
        const static float c3 = 1.f / c1;

        float random = mRandomNumberGenerator.Random();
        float x = (2.f * ((random * c2) + (random * c2) + (random * c2)) - 3.f * (c2 - 1.f)) * c3;
        */
        float x = mRandomNumberGenerator.Random();
        return x;
        //float desc = mRandomNumberGenerator.Random();

        //if(desc > 0.5f)
        //{
        //      return X;
        //}
        //else
        //{
        //      return Y;
        //}
}

---