vetFilterColor.cpp

Go to the documentation of this file.

 #include "vetFilterColor.h"


vetFilterColor::vetFilterColor(vetFilterColorParameters* initParams) : vetFilter()
 {
        INFO("vetFilterColor::vetFilterColor(..* initParams) : vetFilter() [CONTRUCTOR]")

        setParameters(initParams);
        reset();

        setName("Colors Editing Filter");
        setDescription("Posterize, Nagative....");
        setVersion(1.0);

 }

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

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

 }

VETRESULT vetFilterColor::setParameters (vetFilterColorParameters* initParams)
 {

        if ( initParams == NULL )
                myParams = new vetFilterColorParameters();
        else
                myParams = initParams;

        allocateBuffer(myParams->currentBuffer);

        return VETRET_OK;
 }

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

        releaseBuffers();

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

        return VETRET_OK;
 }


VETRESULT vetFilterColor::importFrom(vetFrameYUV420& img)
 {
        DEBUGMSG("VETRESULT vetFilterColor::importFrom(vetFrameYUV420& img) [reading data]", myParams->runMode)

        switch ( myParams->runMode )
         {
         case vetFilterColorParameters::DO_NOTHING:
                        if ( !isBufferYUV() )
                         {
                                useBufferYUV(img.width, img.height);
                                *bufferYUV = img;
                                return VETRET_OK_DEPRECATED;
                         }
                        else
                         {
                                *bufferYUV = img;
                                return VETRET_OK;
                         }

         case vetFilterColorParameters::CLAMP:
                        return clamp(img, myParams->currBpp);

         case vetFilterColorParameters::INVERT:
                        return invert(img, myParams->currBpp);

         case vetFilterColorParameters::EXTRACTBITPLANE:
                        return extractBitPlane(img, myParams->currBits);

         default:
                  return VETRET_PARAM_ERR;
         }
 }


VETRESULT vetFilterColor::importFrom(vetFrameRGB24& img)
 {
        DEBUGMSG("VETRESULT vetFilterColor::importFrom(vetFrameYUV420& img) [reading data]", myParams->runMode)

        switch ( myParams->runMode )
         {
         case vetFilterColorParameters::DO_NOTHING:
                        if ( !isBufferRGB() )
                         {
                                useBufferRGB(img.width, img.height);
                                *bufferRGB = img;
                                return VETRET_OK_DEPRECATED;
                         }
                        else
                         {
                                *bufferRGB = img;

                                return VETRET_OK;
                         }

         case vetFilterColorParameters::CLAMP:
                        return clamp(img, myParams->currBpp);

         case vetFilterColorParameters::INVERT:
                        return invert(img, myParams->currBpp);

         case vetFilterColorParameters::EXTRACTBITPLANE:
                        return extractBitPlane(img, myParams->currBits);

         default:
                  return VETRET_PARAM_ERR;
         }
 }

VETRESULT vetFilterColor::importFrom(vetFrameT<unsigned char>& img)
 {
        DEBUGMSG("VETRESULT vetFilterColor::importFrom(vetFrameT<unsigned char>& img) [reading data]", myParams->runMode)

        switch ( myParams->runMode )
         {
         case vetFilterColorParameters::DO_NOTHING:
                        if ( !isBufferTuC() )
                         {
                                useBufferTuC(img.width, img.height, img.profile);
                                *bufferTuC = img;
                                return VETRET_OK_DEPRECATED;
                         }
                        else
                         {
                                *bufferTuC = img;
                                return VETRET_OK;
                         }


         case vetFilterColorParameters::CLAMP:
                        return clamp(img, myParams->currBpp);

         case vetFilterColorParameters::INVERT:
                        return invert(img, myParams->currBpp);

         case vetFilterColorParameters::EXTRACTBITPLANE:
                        return extractBitPlane(img, myParams->currBits);

         default:
                  return VETRET_PARAM_ERR;
         }
 }





//taglia tutti i valori saturi e negativi
VETRESULT vetFilterColor::clamp(vetFrameYUV420& img, unsigned int bpp)//=sizeof(int)*3
 {

        return VETRET_NOT_IMPLEMENTED;
 }

//taglia tutti i valori saturi
VETRESULT vetFilterColor::clamp(vetFrameRGB24& img, unsigned int bpp)
 {
//CHECKBUGS
        if ( bpp >= sizeof(unsigned char)*3 )
                return VETRET_PARAM_ERR;

        useBufferRGB(img.width, img.height);

        for (unsigned int i=0; i < img.width * img.height; i++ )
         {
                if ( img.data[i][0] > (unsigned char)( (1<<bpp)/3) )
                        bufferRGB->data[i][0] = (unsigned char)( (1<<bpp)/3);
                else
                        bufferRGB->data[i][0] = img.data[i][0];

                if ( img.data[i][1] > (unsigned char)( (1<<bpp)/3) )
                        bufferRGB->data[i][1] = (unsigned char)( (1<<bpp)/3);
                else
                        bufferRGB->data[i][1] = img.data[i][1];

                if ( img.data[i][1] > (unsigned char)( (1<<bpp)/3) )
                        bufferRGB->data[i][1] = (unsigned char)( (1<<bpp)/3);
                else
                        bufferRGB->data[i][2] = img.data[i][2];

         }
        return VETRET_OK;
 }

//taglia tutti i valori saturi e negativi
VETRESULT vetFilterColor::clamp(vetFrameT<unsigned char>& img, unsigned int bpp)//=sizeof(int)*3
 {

        return VETRET_NOT_IMPLEMENTED;
 }


VETRESULT vetFilterColor::invert(vetFrameYUV420& img, unsigned int bpp)//=sizeof(int)*3
 {

        return VETRET_NOT_IMPLEMENTED;
 }

VETRESULT vetFilterColor::invert(vetFrameRGB24& img, unsigned int bpp)//=sizeof(int)*3
 {
//CHECKBUGS

        int maxVal = (1<<bpp)/3-1;

        useBufferRGB(img.width, img.height);

        for (unsigned int i=0; i < img.width * img.height; i++ )
         {
                bufferRGB->data[i][0] = maxVal - img.data[i][0];
                bufferRGB->data[i][1] = maxVal - img.data[i][1];
                bufferRGB->data[i][2] = maxVal - img.data[i][2];
         }

        return VETRET_OK;
 }
VETRESULT vetFilterColor::invert(vetFrameT<unsigned char>& img, unsigned int bpp)//=sizeof(int)*3
 {

        return VETRET_NOT_IMPLEMENTED;
 }


VETRESULT vetFilterColor::extractBitPlane(vetFrameRGB24& img, unsigned int bits)//=1
 {
//CHECKBUGS

        int mask = (1<<bits)/3-1;

        useBufferRGB(img.width, img.height);

        for (unsigned int i=0; i < img.width * img.height; i++ )
         {
                bufferRGB->data[i][0] = (img.data[i][0] & mask) != 0;
                bufferRGB->data[i][1] = (img.data[i][1] & mask) != 0;
                bufferRGB->data[i][2] = (img.data[i][2] & mask) != 0;
         }

        return VETRET_OK;
 }


VETRESULT vetFilterColor::extractBitPlane(vetFrameYUV420& img, unsigned int bits)//=1
 {
        return VETRET_NOT_IMPLEMENTED;
 }

VETRESULT vetFilterColor::extractBitPlane(vetFrameT<unsigned char>& img, unsigned int bits)//=1
 {
        return VETRET_NOT_IMPLEMENTED;
 }























vetFilterColorParameters::vetFilterColorParameters(RUNMODE mode)
 {
        runMode = mode;
        reset();
 }

void vetFilterColorParameters::reset()
 {
        runMode = vetFilterColorParameters::DO_NOTHING;
        currBpp = sizeof(int);
        currBits = 1;
        currentBuffer = vetFilterParameters::NONE;
 }

int vetFilterColorParameters::saveToStreamXML(FILE *fp)
 {

        if ( fp == NULL )
                return VETRET_PARAM_ERR;

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

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

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

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

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

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

        return VETRET_OK;
 }


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

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

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

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

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

        return VETRET_OK;
 }

---