vetFilterNoiseChannel.cpp

Go to the documentation of this file.

#include "vetFilterNoiseChannel.h"

#include <time.h>       // time()
#include <stdlib.h>     // rand()


vetFilterNoiseChannel::vetFilterNoiseChannel(vetFilterNoiseChannelParameters* initParams) : vetFilter()
 {
        INFO("vetFilterNoiseChannel::vetFilterNoiseChannel(..* initParams) : vetFilter() [CONTRUCTOR]")

        zeroRGB[0] = 0;
        zeroRGB[1] = 0;
        zeroRGB[2] = 0;

        oneRGB[0] = 1;
        oneRGB[1] = 1;
        oneRGB[2] = 1;

        zeroChar = '0';
        oneChar = '1';

        setParameters(initParams);
        reset();

        setName("Noise Channel Simulator Filter");
        setDescription("Additive noise or others..");
        setVersion(1.0);

  }

vetFilterNoiseChannel::~vetFilterNoiseChannel()
 {
        INFO("vetFilterNoiseChannel::~vetFilterNoiseChannel() [DESTRUCTOR]")

        if (myParams != NULL)
                delete myParams;//BUG
        myParams = NULL;

 }

VETRESULT vetFilterNoiseChannel::setParameters (vetFilterNoiseChannelParameters* initParams)
 {
        if ( initParams == NULL )
                myParams = new vetFilterNoiseChannelParameters();
        else
                myParams = initParams;

        allocateBuffer(myParams->currentBuffer);

        return VETRET_OK;
 }

VETRESULT vetFilterNoiseChannel::reset()
 {
        INFO("VETRESULT vetFilterNoiseChannel::reset() [SET DEFAULT PARAMETERS]")

        releaseBuffers();

        if (myParams != NULL)
         {
                myParams->reset();
                allocateBuffer(myParams->currentBuffer);
         }
        else
                setParameters(NULL);

        resetNoiseSource();
        externalSource = NULL;

        return VETRET_OK;
 }



void vetFilterNoiseChannel::generateNoise(vetFrameYUV420& img, unsigned char zero)
 {
        unsigned int size = img.getBufferSize();
        unsigned int perc = (unsigned int)( (float)size * myParams->spread);
        int noiseco = 0;
        int norm = myParams->normalize_value;

        for ( unsigned int i = 0; i < size; i++ )
                img.data[i] = zero;

        if ( myParams->normalized )
         {
                for ( unsigned int i = 0; i < perc; i++ )
                 {
                        img.data[ noiseco = rand()*rand() % size ] = rand() % norm;
                 }
         }
        else
         {
                for ( unsigned int i = 0; i < perc; i++ )
                 {
                        img.data[ rand()*rand() % size ] = (unsigned char)rand();
                 }
         }
 }

void vetFilterNoiseChannel::generateNoise(vetFrameRGB24& img,  PixelRGB24 zero)
 {
        unsigned int size = img.getBufferSize();
        unsigned int perc = (unsigned int)( (float)size * myParams->spread);
        unsigned int noiseco = 0;
        int norm = myParams->normalize_value;

        for ( unsigned int i = 0; i < size; i++ )
                img.data[i] = zero;

        if ( myParams->normalized )
         {
                for ( unsigned int i = 0; i < perc; i++ )
                 {
                        noiseco = rand()*rand() % size;
                        img.data[noiseco][0] = (unsigned char)( rand() % norm);
                        noiseco = rand()*rand() % size;
                        img.data[noiseco][1] = (unsigned char)( rand() % norm);
                        noiseco = rand()*rand() % size;
                        img.data[noiseco][2] = (unsigned char)( rand() % norm);
                 }
         }
        else
         {
                for ( unsigned int i = 0; i < perc; i++ )
                 {
                        noiseco = rand()*rand() % size;
                        img.data[noiseco][0] = (unsigned char)rand();
                        noiseco = rand()*rand() % size;
                        img.data[noiseco][1] = (unsigned char)rand();
                        noiseco = rand()*rand() % size;
                        img.data[noiseco][2] = (unsigned char)rand();
                 }
         }
 }

void vetFilterNoiseChannel::generateNoise(vetFrameT<unsigned char>& img, unsigned char zero)
 {
        unsigned int size = img.getBufferSize();
        unsigned int perc = (unsigned int)( (float)size * myParams->spread);
        int noiseco = 0;
        int norm = myParams->normalize_value;

        for ( unsigned int i = 0; i < size; i++ )
                img.data[i] = zero;

        if ( myParams->normalized )
         {
                for ( unsigned int i = 0; i < perc; i++ )
                 {
                        img.data[ noiseco = rand()*rand() % size ] = rand() % norm;
                 }
         }
        else
         {
                for ( unsigned int i = 0; i < perc; i++ )
                 {
                        img.data[ rand()*rand() % size ] = rand();
                 }
         }
 }


VETRESULT vetFilterNoiseChannel::AddNoise(vetFrameYUV420& img)
 {
        INFO("VETRESULT vetFilterNoiseChannel::AddNoise(vetFrameYUV420& img)")

        if ( !isBufferYUV() )
         {
                useBufferYUV(img.width, img.height);
                //ret = VETRET_OK_DEPRECATED;
         }

        if ( externalSource == NULL )
                generateNoise(*bufferYUV,  zeroChar);
        else
                *externalSource >> *bufferYUV;

        *bufferYUV += img;

        return VETRET_OK;
 }


VETRESULT vetFilterNoiseChannel::AddNoise(vetFrameRGB24& img)
 {
        INFO("VETRESULT vetFilterNoiseChannel::AddNoise(vetFrameRGB24& img)")

        if ( !isBufferRGB() )
         {
                useBufferRGB(img.width, img.height);
                //ret = VETRET_OK_DEPRECATED;
         }

        if ( externalSource == NULL )
                generateNoise(*bufferRGB,  zeroRGB);
        else
                *externalSource >> *bufferRGB;

        *bufferRGB += img;

        return VETRET_OK;
 }


VETRESULT vetFilterNoiseChannel::AddNoise(vetFrameT<unsigned char>& img)
 {
        INFO("VETRESULT vetFilterNoiseChannel::AddNoise(vetFrameT<unsigned char>& img)")

        if ( !isBufferTuC() )
         {
                useBufferTuC(img.width, img.height, img.profile);
                //ret = VETRET_OK_DEPRECATED;
         }

        if ( externalSource == NULL )
                generateNoise(*bufferTuC,  zeroChar);
        else
                *externalSource >> *bufferTuC;

        *bufferTuC += img;

        return VETRET_OK;
 }

VETRESULT vetFilterNoiseChannel::MultiplyNoise(vetFrameYUV420& img)
 {
        INFO("VETRESULT vetFilterNoiseChannel::MultiplyNoise(vetFrameYUV420& img)")

        if ( !isBufferYUV() )
         {
                useBufferYUV(img.width, img.height);
                //ret = VETRET_OK_DEPRECATED;
         }

        if ( externalSource == NULL )
                generateNoise(*bufferYUV,  oneChar);
        else
                *externalSource >> *bufferYUV;

        *bufferYUV *= img;

        return VETRET_OK;
 }


VETRESULT vetFilterNoiseChannel::MultiplyNoise(vetFrameRGB24& img)
 {
        INFO("VETRESULT vetFilterNoiseChannel::MultiplyNoise(vetFrameRGB24& img)")

        if ( !isBufferRGB() )
         {
                useBufferRGB(img.width, img.height);
                //ret = VETRET_OK_DEPRECATED;
         }

        if ( externalSource == NULL )
                generateNoise(*bufferRGB,  oneRGB);
        else
                *externalSource >> *bufferRGB;

//BUG BUG BUG BUG BUG BUG
//      *bufferRGB *= img;

        return VETRET_OK;
 }

VETRESULT vetFilterNoiseChannel::MultiplyNoise(vetFrameT<unsigned char>& img)
 {
        INFO("VETRESULT vetFilterNoiseChannel::MultiplyNoise(vetFrameT<unsigned char>& img)")

        if ( !isBufferTuC() )
         {
                useBufferTuC(img.width, img.height, img.profile);
                //ret = VETRET_OK_DEPRECATED;
         }

        if ( externalSource == NULL )
                generateNoise(*bufferTuC,  oneChar);
        else
                *externalSource >> *bufferTuC;

//BUG
//*bufferTuC *= img;

        return VETRET_OK;
 }



void vetFilterNoiseChannel::resetNoiseSource()
 {
        INFO("void vetFilterNoiseChannel::resetNoiseSource()")

        // initialise random sunber generator
        time_t t;
        srand((unsigned) time(&t));

 }

VETRESULT vetFilterNoiseChannel::setNoiseSource(vetInput& frameSource)
 {
        DEBUGMSG("VETRESULT vetFilterNoiseChannel::setNoiseSource(vetInput& frameSource)", &frameSource)

        externalSource = &frameSource;

        return VETRET_OK;
 }






VETRESULT vetFilterNoiseChannel::importFrom(vetFrameYUV420& img)
 {
        INFO("VETRESULT vetFilterNoiseChannel::importFrom(vetFrameYUV420& img) [reading data]")

        if ( myParams->operation == vetFilterNoiseChannelParameters::ADDITIVE )
                AddNoise(img);
        else if ( myParams->operation == vetFilterNoiseChannelParameters::MULTIPLICATIVE )
                MultiplyNoise(img);

        return VETRET_OK;
 }

VETRESULT vetFilterNoiseChannel::importFrom(vetFrameRGB24& img)
 {
        INFO("VETRESULT vetFilterNoiseChannel::importFrom(vetFrameYUV420& img) [reading data]")

        if ( myParams->operation == vetFilterNoiseChannelParameters::ADDITIVE )
                AddNoise(img);
        else if ( myParams->operation == vetFilterNoiseChannelParameters::MULTIPLICATIVE )
                MultiplyNoise(img);

        return VETRET_OK;
 }

VETRESULT vetFilterNoiseChannel::importFrom(vetFrameT<unsigned char>& img)
 {
        INFO("VETRESULT vetFilterNoiseChannel::importFrom(vetFrameT<unsigned char>& img) [reading data]")

        if ( myParams->operation == vetFilterNoiseChannelParameters::ADDITIVE )
                AddNoise(img);
        else if ( myParams->operation == vetFilterNoiseChannelParameters::MULTIPLICATIVE )
                MultiplyNoise(img);

        return VETRET_OK;
 }







vetFilterNoiseChannelParameters::vetFilterNoiseChannelParameters(NOISEOPER mode)
 {
        reset();
        operation = mode;
 }

void vetFilterNoiseChannelParameters::reset()
 {
        operation = vetFilterNoiseChannelParameters::ADDITIVE;
        normalized = false;
        normalize_value = 255;
        spread = 1.;
        currentBuffer = vetFilterParameters::NONE;
 }



int vetFilterNoiseChannelParameters::saveToStreamXML(FILE *fp)
 {

        if ( fp == NULL )
                return VETRET_PARAM_ERR;

        if( fprintf(fp, "<vetFilterNoiseChannelParameters>\n") == EOF )
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <operation value=\"%i\" />\n", (int)operation) == EOF)
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <spread value=\"%f\" />\n", spread) == EOF)
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <normalized enabled=\"%u\" value=\"%u\" />\n", (int)normalized, normalize_value) == EOF)
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <internalBufferType value=\"%u\" />\n", (int)currentBuffer) == EOF)
                return VETRET_INTERNAL_ERR;

        if( fprintf(fp, "</vetFilterNoiseChannelParameters>\n") == EOF )
                return VETRET_INTERNAL_ERR;

        return VETRET_OK;
 }



int vetFilterNoiseChannelParameters::loadFromStreamXML(FILE *fp)
 {
        if ( fscanf(fp, "<vetFilterNoiseChannelParameters>\n") == EOF )
                throw "error in XML file, unable to import data.";

        int runTmp = 0;
        if ( fscanf(fp, "  <operation value=\"%i\" />\n", &runTmp) == EOF )
                throw "error in XML file, unable to import data.";
        else
                operation = (NOISEOPER)runTmp;

        if ( fscanf(fp, "  <spread value=\"%f\" />\n", &spread) == EOF )
                throw "error in XML file, unable to import data.";

        int boolTmp = 0;
        if ( fscanf(fp, "  <normalized enabled=\"%u\" value=\"%u\" />\n", &boolTmp, &normalize_value) == EOF )
                throw "error in XML file, unable to import data.";

        if (boolTmp == 0)
                normalized = false;
        else
                normalized = true;

        int cB = (int)currentBuffer;
        if ( fscanf(fp, "  <internalBufferType value=\"%u\" />\n", &cB) == EOF )
                throw "error in XML file, unable to import data.";

        return VETRET_OK;
 }

---