vetFilterNoiseChannel.h

#ifndef __VETLIB_VETFILTERNOISECHANNEL_H__
 #define __VETLIB_VETFILTERNOISECHANNEL_H__

 #include "../vetDefs.h"
 #include "../vetFilter.h"

 #include "../vetFrameYUV420.h"
 #include "../vetFrameRGB24.h"
 #include "../vetFrameT.h"



class vetFilterNoiseChannelParameters : public vetFilterParameters
{
        public:

                enum NOISEOPER{ ADDITIVE, MULTIPLICATIVE };

        protected:

                NOISEOPER operation;
                bool normalized;
                float spread;
                int normalize_value;

                friend class vetFilterNoiseChannel;


        public:

                vetFilterNoiseChannelParameters(NOISEOPER mode = vetFilterNoiseChannelParameters::ADDITIVE);
                ~vetFilterNoiseChannelParameters() {}

                void reset();

                void setOperation(NOISEOPER mode) { operation = mode; };
                NOISEOPER getOperation() { return operation; };

                void setNormalisedNoise(bool value = true) { normalized = value; };
                bool isNormalisedNoise() { return normalized; };

                void setNormalisedNoiseValue(int value) { normalize_value = value; };
                int getNormalisedNoiseValue() { return normalize_value; };

                void setSpread(float value) { spread = value; };
                float isSpread() { return spread; };


                VETRESULT saveToStreamXML(FILE *fp);
                VETRESULT loadFromStreamXML(FILE *fp);


};

class vetFilterNoiseChannel :   public vetFilter
 {

 protected:

                vetFilterNoiseChannelParameters* myParams;

                vetInput* externalSource;

                PixelRGB24 zeroRGB;
                PixelRGB24 oneRGB;

                unsigned char zeroChar;
                unsigned char oneChar;

                void generateNoise(vetFrameYUV420& img, unsigned char zero);
                void generateNoise(vetFrameRGB24& img, PixelRGB24 zero);
                void generateNoise(vetFrameT<unsigned char>& img, unsigned char zero);

 public:


                vetFilterNoiseChannel(vetFilterNoiseChannelParameters* initParams = NULL);

                ~vetFilterNoiseChannel();

                VETRESULT setParameters(vetFilterNoiseChannelParameters* initParams);

                vetFilterNoiseChannelParameters& getParameters() { return *myParams; };

                VETRESULT setFilterParameters (vetFilterNoiseChannelParameters* initParams)
                 {
                        if (initParams == NULL)
                                return setParameters(NULL);
                        else
                                return setParameters(static_cast<vetFilterNoiseChannelParameters*>(initParams));
                 };



                vetFilterParameters* getFilterParameters ()
                 {
                        if (myParams == NULL)
                                return NULL;
                        else
                                return static_cast<vetFilterParameters*>(myParams);
                 };

                VETRESULT reset();


                // take care of frame rate and neutral pixel (0 for add, 1 for mult)
                VETRESULT setNoiseSource(vetInput& frameSource);

                //internal
                void resetNoiseSource();



                VETRESULT AddNoise(vetFrameYUV420& img);
                VETRESULT AddNoise(vetFrameRGB24& img);
                VETRESULT AddNoise(vetFrameT<unsigned char>& img);

                VETRESULT MultiplyNoise(vetFrameYUV420& img);
                VETRESULT MultiplyNoise(vetFrameRGB24& img);
                VETRESULT MultiplyNoise(vetFrameT<unsigned char>& img);




                VETRESULT importFrom(vetFrameYUV420& img);

                VETRESULT importFrom(vetFrameRGB24& img);

                VETRESULT importFrom(vetFrameT<unsigned char>& img);



};



#endif //__VETLIB_VETFILTERNOISECHANNEL_H__

/*
//TODO
        S/N // -> calcolo potenze!

*/

---