vetMotionIlluminationInvariant.cpp

Go to the documentation of this file.

#include "vetMotionIlluminationInvariant.h"
#include <math.h>


 #define RED_COEF .2989961801
 #define GREEN_COEF .5869947588
 #define BLUE_COEF .1139912943


#include "../filters/vetDigitalFilter.h" // lowpass and average


vetDFMatrix* gaussian = vetDFMatrix::createKernel_3x3(VETDF_3x3_gaussian);
vetDFMatrix* myLowpass = vetDFMatrix::createKernel_3x3(VETDF_3x3_lowpass1);


vetMotionIlluminationInvariant::vetMotionIlluminationInvariant(vetMotionIlluminationInvariantParameters* initParams) : vetVision()
 {
        INFO("vetMotionIlluminationInvariant::vetMotionIlluminationInvariant(..* initParams)  : vetMotion() [CONTRUCTOR]")

        buffer = NULL;
        reflectance = NULL;

        setParameters(initParams);
        reset();
 }

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

        if (buffer != NULL)
                delete buffer;

        if (reflectance != NULL)
                delete reflectance;


        delete myParams;//BUG

 }

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

        if (buffer != NULL)
                delete buffer;
        buffer = NULL;

        if (reflectance != NULL)
                delete reflectance;
        reflectance = NULL;

        alertCall = NULL;
        alertCallArgument = NULL;

        lastDiffValue = 0;

        setName("Lame Motion Detection");
        setDescription("detect difference between 2 frames.");
        setVersion(1.0);

        return VETRET_OK;
 }


VETRESULT vetMotionIlluminationInvariant::setParameters(vetMotionIlluminationInvariantParameters* initParams)
 {
        if ( initParams == NULL )
                myParams = new vetMotionIlluminationInvariantParameters();
        else
                myParams = initParams;

        return VETRET_OK;
 }




void vetMotionIlluminationInvariant::initFrame(vetFrameRGB24& img)
 {
        if (buffer != NULL)
                delete buffer;

        buffer = new vetFrameT<unsigned char>(img.width, img.height);

        if (reflectance != NULL)
                delete reflectance;

        reflectance = new vetFrameT<unsigned char>(img.width, img.height);
        diff = new vetFrameT<unsigned char>(img.width, img.height);

        getReflectance(*reflectance, img);

        lastDiffValue = 0;
 }






VETRESULT vetMotionIlluminationInvariant::importFrom(vetFrameRGB24& img)
 {
        INFO("int vetMotionIlluminationInvariant::importFrom(vetFrameRGB24& img) [reading data]")

        if (buffer == NULL)
         {
                initFrame(img);
                return VETRET_OK;
         }

        getReflectance(*buffer, img);
        getDifference(*diff,*buffer, *reflectance);


        if ( myParams->doEval && evalDifference(*diff) && myParams->doAlert )
                doAlert();

        vetFrameT<unsigned char>* tmp = reflectance;
        reflectance = buffer;//bug
        buffer = tmp;

        return VETRET_OK;
 }




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

        return VETRET_NOT_IMPLEMENTED;
 }



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

        return VETRET_NOT_IMPLEMENTED;
 }



int vetMotionIlluminationInvariant::evalDifference(vetFrameT<unsigned char>& diff_img)
 {
        INFO("")

        unsigned char* diff_ptr = diff_img.data;
        vetFrameT<unsigned char> tmp(diff_img.width, diff_img.height);

        // LP average 5x5
        vetDigitalFilter::doProcessing(diff_img, tmp, *myLowpass);

        lastDiffValue=0;
        for (unsigned int i=0; i< diff_img.width*diff_img.height; i++)
         {
                lastDiffValue += (long)*diff_ptr;
         }


//      if ( myParams->threshold > lastDiffValue )
//              return 0;

        return lastDiffValue;
 }

int vetMotionIlluminationInvariant::evalDifference(vetFrameRGB24& diff_img)
 {
        INFO("")

        vetFrameRGB24 tmp(diff_img.width, diff_img.height);

        // LP average 5x5
        vetDigitalFilter::doProcessing(diff_img, tmp, *myLowpass);

        lastDiffValue=0;
        for (unsigned int i=0; i< diff_img.width*diff_img.height; i++)
         {
                lastDiffValue += (long)( (float)diff_img.data[i][0] * RED_COEF + (float)diff_img.data[i][0] * GREEN_COEF + (float)diff_img.data[i][0] * BLUE_COEF);
         }

//      if ( myParams->threshold > lastDiffValue )
//              return 0;

        return lastDiffValue;
 }





VETRESULT vetMotionIlluminationInvariant::getReflectance(vetFrameT<unsigned char> &refl_img, vetFrameRGB24& source_img)
 {
        unsigned char* refl_ptr = refl_img.data;
        unsigned int i=0;

        vetFrameT<float> buffer(source_img.width, source_img.height);
        vetFrameT<float> lowpass(source_img.width, source_img.height);

        float* buffer_ptr = buffer.data;
        float* lowpass_ptr = lowpass.data;

// refl_img <= log(source_img) = log(illumination) + log (reflectance)

        for (i=0; i< source_img.width*source_img.height; i++, buffer_ptr++)
         {
                *buffer_ptr = (float)log( (float)source_img.data[i][0] * RED_COEF + (float)source_img.data[i][0] * GREEN_COEF + (float)source_img.data[i][0] * BLUE_COEF );
         }


// l = LOWPASS(r) , illumination = exp( LOWPASS( log(source_img) ) )

        vetDigitalFilter::doProcessing(buffer, lowpass, *gaussian);


// refl_img = refl_img - l , reflectance = exp( log(source_img) - LOWPASS( log(source_img) )
        buffer_ptr = buffer.data;
        for (i=0; i< source_img.width*source_img.height; i++, lowpass_ptr++, buffer_ptr++)
         {
                *buffer_ptr -= *lowpass_ptr;
//              *buffer_ptr = *lowpass_ptr - *buffer_ptr;
         }


// refl_img <= exp(refl_img)

        buffer_ptr = buffer.data;
        for (i=0; i< source_img.width*source_img.height; i++, refl_ptr++, buffer_ptr++)
         {
                *refl_ptr = (unsigned char) exp(*buffer_ptr);
         }

        return VETRET_OK;
 }


















VETRESULT vetMotionIlluminationInvariant::getReflectance(vetFrameRGB24& source_img, vetFrameRGB24& refl_img)
 {

        unsigned char* refl_ptr = refl_img.data[0];

        vetFrameT<float> buffer(source_img.width, source_img.height);
        vetFrameT<float> lowpass(source_img.width, source_img.height);

        float* buffer_ptr = buffer.data;
        float* lowpass_ptr = lowpass.data;

        float tmp = 0;
        unsigned int i;

// refl_img <= log(source_img) = log(illumination) + log (reflectance)

        for (i=0; i< source_img.width*source_img.height; i++, buffer_ptr++)
         {
//              *buffer_ptr = log( (float)*source_ptr );
                tmp = (float)( (float)source_img.data[i][0] * RED_COEF + (float)source_img.data[i][0] * GREEN_COEF + (float)source_img.data[i][0] * BLUE_COEF );
                if (tmp)
                        *buffer_ptr = (float)log( tmp );

         }


// l = LOWPASS(r) , illumination = exp( LOWPASS( log(source_img) ) )

        vetDigitalFilter::doProcessing(buffer, lowpass, *gaussian);


// refl_img = refl_img - l , reflectance = exp( log(source_img) - LOWPASS( log(source_img) )

        buffer_ptr = buffer.data;
        for (i=0; i< source_img.width*source_img.height; i++, lowpass_ptr++, buffer_ptr++)
         {
//              *buffer_ptr -= *lowpass_ptr;
                *buffer_ptr = *lowpass_ptr - *buffer_ptr;

         }


// refl_img <= exp(refl_img)
        buffer_ptr = buffer.data;
        for (i=0; i< source_img.width*source_img.height; i++)
         {
                *refl_ptr = (unsigned char) exp(*buffer_ptr);
                *(refl_ptr+1) = (unsigned char) exp(*buffer_ptr);
                *(refl_ptr+2) = (unsigned char) exp(*buffer_ptr);
                refl_ptr += 3;
                buffer_ptr++;
         }

        return VETRET_OK;
 }


VETRESULT vetMotionIlluminationInvariant::getIllumination(vetFrameRGB24& source_img, vetFrameRGB24& ill_img)
 {
        vetFrameT<float> buffer(source_img.width, source_img.height);
        vetFrameT<float> ill(source_img.width, source_img.height);

        float* buffer_ptr = buffer.data;
        float* ill_ptr = ill.data;
        unsigned char* ret_ptr = ill_img.data[0];

        float tmp;
        unsigned int i;

        for (i=0; i< source_img.width*source_img.height; i++, buffer_ptr++)
         {
                tmp = (float)( (float)source_img.data[i][0] * RED_COEF + (float)source_img.data[i][0] * GREEN_COEF + (float)source_img.data[i][0] * BLUE_COEF);
                if (tmp)
                        *buffer_ptr = (float)log( tmp );
         }

        vetDigitalFilter::doProcessing(buffer, ill, *gaussian);

        for (i=0; i< source_img.width*source_img.height; i++)
         {
                *ret_ptr = (unsigned char) exp(*ill_ptr);
                *(ret_ptr+1) = (unsigned char) exp(*ill_ptr);
                *(ret_ptr+2) = (unsigned char) exp(*ill_ptr);
                ret_ptr += 3;
                ill_ptr++;
         }

        return VETRET_OK;
 }






vetMotionIlluminationInvariantParameters::vetMotionIlluminationInvariantParameters(unsigned int threshold, bool doAlert)
 {
        reset();

        setDoAlert(doAlert);
        setThresholdValue(threshold);
 }

void vetMotionIlluminationInvariantParameters::reset()
 {
        doAlert = false;
        threshold = 1;
 }


void vetMotionIlluminationInvariantParameters::setThresholdValue(unsigned int value)
 {
        threshold = value;
 }



VETRESULT vetMotionIlluminationInvariantParameters::saveToStreamXML(FILE *fp)
 {

        if ( fp == NULL )
                return VETRET_PARAM_ERR;

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

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

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

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

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

        return VETRET_OK;
 }


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

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

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

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

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

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

        return VETRET_OK;
 }

---