vetHist.cpp

Go to the documentation of this file.

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

 #include <stdio.h>
 #include <fstream>



vetHist::vetHist()
 {
        freqHist = NULL;
        probHist = NULL;
        reset();
 }

vetHist::vetHist(int MinValue, int MaxValue)
 {
        freqHist = NULL;
        probHist = NULL;
        reset(MinValue, MaxValue);
 }


vetHist::vetHist(vetFrameYUV420& img, vetFrameYUV420::ChannelYUV channel)
 {
        freqHist = NULL;
        probHist = NULL;

        fromImage(img, channel);
 }

vetHist::vetHist(vetFrameRGB24& img, vetFrameRGB24::ChannelRGB channel)
 {
        freqHist = NULL;
        probHist = NULL;

        fromImage(img, channel);
 }

vetHist::~vetHist()
 {

        if ( freqHist != NULL )
                delete [] freqHist;

        if ( probHist != NULL )
                delete [] probHist;


 }



VETRESULT vetHist::reset()
 {

        valMax = 0;
        valMin = 0;
        valBandwidth = 0;
        valCount = 0;

        valSum = 0;
        valSum2 = 0;


        if ( freqHist != NULL )
                delete [] freqHist;

        freqMax = 0;
        freqMin = 0;

        if ( probHist != NULL )
                delete [] probHist;

        probMax = 0;
        probMin = 0;

        return VETRET_OK;
 }


VETRESULT vetHist::reset(int MinValue, int MaxValue)
 {
        reset();
        valMax = MaxValue;
        valMin = MinValue;
        valCount = 0;

        valBandwidth = abs(valMax - valMin+1);

        if ( freqHist != NULL )
                delete [] freqHist;
        freqHist = new unsigned int[valBandwidth];

        freqMax = 0;
        freqMin = 0;

        if ( probHist != NULL )
                delete [] probHist;
        probHist = new float[valBandwidth];

        probMax = 0;
        probMin = 0;

        for (int i=0; i < valBandwidth; i++)
         {
                probHist[i] = 0.0;
                freqHist[i] = 0;
         }

        return VETRET_OK;
 }

VETRESULT vetHist::addValue(int data)
 {
        if ( data < valMin || data > valMax)
                return VETRET_PARAM_ERR;

        if ( valBandwidth == 0 )
                return VETRET_ILLEGAL_USE;

        int offset = data - valMin;

        freqHist[offset]++;
        valCount++;

        valSum  += data;
        valSum2 += data * data;


        if ( freqMax < freqHist[offset])
                freqMax = freqHist[offset];

        if ( freqMin > freqHist[offset])
                freqMin = freqHist[offset];

        return VETRET_OK;
 }

VETRESULT vetHist::addData(int *data, int size)
 {

        if ( data == NULL || size == 0)
                return VETRET_PARAM_ERR;

        if ( valBandwidth == 0 )
                return VETRET_ILLEGAL_USE;

        int offset;
        for (int i=0; i<size; i++)
         {
                offset = data[i] - valMin;

                freqHist[offset]++;
                valCount++;

                valSum  += data[i];
                valSum2 += data[i] * data[i];

                if ( freqMax < freqHist[offset])
                        freqMax = freqHist[offset];

                if ( freqMin > freqHist[offset])
                        freqMin = freqHist[offset];
         }

        return VETRET_OK;

 }


VETRESULT vetHist::fromImage(vetFrameYUV420& img, vetFrameYUV420::ChannelYUV channel)
 {
        reset( 0, (int)pow((float)2.0, (float) (1<<sizeof(int)) ) );

        unsigned int offset;
        unsigned int start, end;

        if ( channel == vetFrameYUV420::Lum )
         {
                start = 0;
                end = img.width*img.height;
         }
        else if ( channel == vetFrameYUV420::Cb )
         {
                start = img.width*img.height;
                end = (unsigned int)(img.width*img.height*1.25);
         }
        else if ( channel == vetFrameYUV420::Cr )
         {
                start = img.width*img.height;
                end = (unsigned int)(img.width*img.height*1.5);
         }
        else
         {
                reset();
                return VETRET_PARAM_ERR;
         }
        for (unsigned int i=start; i<end; i++)
         {

                offset = img.data[i];

                freqHist[offset]++;
                valCount++;

                valSum  += offset;
                valSum2 += offset * offset;

                if ( freqMax < freqHist[offset])
                        freqMax = freqHist[offset];

                if ( freqMin > freqHist[offset])
                        freqMin = freqHist[offset];

         }

         extractProbs();

         return VETRET_OK;

 }


VETRESULT vetHist::fromImage(vetFrameRGB24& img, vetFrameRGB24::ChannelRGB channel)
 {
//      reset( 0, (int)pow((float)2.0, (float) (1<<sizeof(unsigned char)) ) );
        reset( 0, 255 );

//        int temp = 1<<sizeof(char);
//printf("%d", temp);

        int offset;

        for (unsigned int i=0; i<img.width*img.height; i++)
         {
                offset = (unsigned int)img.data[i][channel];

                freqHist[offset]++;
                valCount++;

                valSum  += offset;
                valSum2 += offset * offset;

                if ( freqMax < freqHist[offset])
                        freqMax = freqHist[offset];

                if ( freqMin > freqHist[offset])
                        freqMin = freqHist[offset];

         }

         extractProbs();

         return VETRET_OK;
 }




VETRESULT vetHist::extractProbs()
{
        if ( freqHist == NULL || probHist == NULL )
                return VETRET_ILLEGAL_USE;

        if ( valBandwidth == 0 )
                return VETRET_ILLEGAL_USE;


        probMax = 0;
        probMin = 1;

        for (int i=0; i < valBandwidth; i++)
         {
                probHist[i] = (float)freqHist[i] / (float)valCount;

                if ( probHist[i] > probMax )
                        probMax = probHist[i];

                if ( probHist[i] < probMin )
                        probMin = probHist[i];

         }

        return VETRET_OK;
}




float vetHist::extractDifference(vetHist *compareHist)
{

        if ( valBandwidth == 0 )
                return VETRET_ILLEGAL_USE;

        extractProbs();
        compareHist->extractProbs();

        float diffTmp = 0;
        float diff = 0;

        for (int i=0; i < valBandwidth; i++)
         {
                diffTmp = probHist[i] - compareHist->probHist[i];

                if ( diffTmp < 0.0 )
                        diff -= diffTmp;
                else
                        diff += diffTmp;

         }

    return diff;
}


float vetHist::getMean() const
{
  return valSum/(double)valCount;
}

float vetHist::getVariance() const
{
  float n = (double)valCount;
  return (n*valSum2 - valSum*valSum)/(n*n);
}

/*
float vetHist::getEntropy() const
{
  const float log2c = log(2.0);
  float* px = new float [xNbins];
  unsigned long int i;
  for (i = 0; i < xNbins; i++)
    px[i] = (1.0/(float)valCount)*(float)data[i];

  float entropy = 0.0;
  for (i = 0; i < xNbins; i++)
    if (px[i] != 0.0)
      entropy -= px[i]*log(px[i])/log2c;

  delete [] px;

  return entropy;
}
*/

unsigned char   graphBackground[] =     {  12,23

                                                                };

VETRESULT vetHist::drawGraph(vetFrameRGB24& img)
 {
//assert 400x400
        unsigned int upperBorder = 35;//<img.height
        unsigned int bottomBorder = 45;//<img.height
        unsigned int leftBorder = 100;//<img.width-255
        bool fillCol = true;

        if (img.width < leftBorder+255)
                return VETRET_ILLEGAL_USE;

        if ( freqHist == NULL )
                return VETRET_ILLEGAL_USE;

        PixelRGB24 black(0,0,0);
        PixelRGB24 grey(192,192,192);
        PixelRGB24 back(255,255,255);

        img.clearWith(back);

        unsigned int y;
        float scale = (float)(img.height-(upperBorder+bottomBorder)) / (float)freqMax;
        unsigned int offset = img.height * img.width - bottomBorder * img.width + leftBorder;

printf("value %d\n" , offset);

        for (unsigned int x=0; x<255; x++)
         {
                y = (unsigned int)( (float)freqHist[x] * scale);
//printf("value %d" , y);
//setpixel ( x+leftBorder, img.height-y-bottomBorder)
//              img.data[x+leftBorder   +  (img.height-y-bottomBorder) * img.width] = black;
                img.data[offset + x - y * img.width] = black;

                if (fillCol)
                        while (y++ < (img.height-upperBorder-bottomBorder))
                                img.data[offset + x - y * img.width] = grey;

         }

        return VETRET_OK;
 }




VETRESULT vetHist::saveToXML(const char* filename)
{
    FILE *fp;
        int ret = VETRET_OK;

        if ( valBandwidth == 0 )
        return VETRET_INTERNAL_ERR;

    if ( (fp = fopen(filename, "w")) == NULL )
        return VETRET_PARAM_ERR;

    ret = extractProbs();

    if ( ret != VETRET_OK )
        return ret;

    if( fprintf(fp, "<?xml version=\"1.0\" ?>\n\n") == EOF )
         {
                fclose(fp);
                return VETRET_INTERNAL_ERR;
         }

    if( fprintf(fp, "<histogram value-count=\"%i\" min-value=\"%i\" max-value=\"%i\">\n", valCount, valMin, valMax) == EOF )
         {
            fclose(fp);
        return VETRET_INTERNAL_ERR;
         }

        if (!extractProbs())
                for (int i=0; i < valBandwidth; i++)
                 {
                        if ( fprintf(fp, "  <prob index=\"%u\">%f</prob>\n", i, probHist[i]) == EOF)
                        ret = VETRET_INTERNAL_ERR;
             }
        else
        ret = VETRET_INTERNAL_ERR;

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

    fclose(fp);

        return ret;
 }


VETRESULT vetHist::loadFromXML(const char* filename)
{
    FILE *fp;
        int ret = VETRET_OK;

    if ( (fp=fopen(filename,"r")) == NULL )
        return VETRET_PARAM_ERR;

    int n;  // return values for fscanf, set to number of items read

    /* xml version string */

    float xmlversion = 0;

    n = fscanf(fp, "<?xml version=\"%f\" ?>\n\n", &xmlversion);

    if (xmlversion == 0)
        throw "Incompatible hst file format";


    /* histogram attributes */

    n = fscanf(fp, "<histogram value-count=\"%i\" min-value=\"%i\" max-value=\"%i\">\n", &valCount, &valMin, &valMax);

    if (n != 4)
        throw "error in hst file, unable to import data.";

        reset(valMin, valMax);

    unsigned int i = 0;
    float p = 0;

    while (n == 2)
     {
        n = fscanf(fp, "  <prob index=\"%u\">%f</prob>\n", &i, &p);
        probHist[i] = p;
     }


    char last[2];
    n = fscanf(fp, "/histogram%[>]", last);

    if (n != 1)
        throw "Reading hst file.";

    fclose(fp);

    return ret;
 }

---