vetFrameGrey.cpp

Go to the documentation of this file.

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

vetFrameGrey::vetFrameGrey() : vetFrame()
 {
        data = NULL;
        width = 0;
        height = 0;

        INFO("vetFrameGrey::vetFrameGrey() : vetFrame() [CONTRUCTOR]")
 }

vetFrameGrey::vetFrameGrey(unsigned int w, unsigned int h)
{
        data = NULL;
        reAllocCanvas(w, h);

        INFO("vetFrameGrey::vetFrameGrey(unsigned int w, unsigned int h) [CONTRUCTOR]")
        DEBUG(width)
        DEBUG(height)
 }

vetFrameGrey::vetFrameGrey(vetFrameGrey& img)

{
        data = NULL;
        reAllocCanvas(img.width, img.height);

        if ( width != 0 && height != 0 )
                memcpy(data, img.data, width * height * sizeof(PixelGrey));

        INFO("vetFrameGrey::vetFrameGrey(vetFrameGrey& img) [CONTRUCTOR]")
        DEBUG(width)
        DEBUG(height)
 }


vetFrameGrey::vetFrameGrey(vetFrameYUV420& img)
 {
        INFO("vetFrameGrey::vetFrameGrey(vetFrameYUV420& img) [CONTRUCTOR]")

        data = NULL;
        reAllocCanvas(img.width, img.height);
        *this << img;

        DEBUG(width)
        DEBUG(height)
 }

vetFrameGrey::vetFrameGrey(vetFrameRGB24& img)
 {
        INFO("vetFrameGrey::vetFrameGrey(vetFrameRGB24& img) [CONTRUCTOR]")

        data = NULL;
        reAllocCanvas(img.width, img.height);
        *this << img;

        DEBUG(width)
        DEBUG(height)
 }

vetFrameGrey::vetFrameGrey(vetFrameRGB96& img)
 {
        INFO("vetFrameGrey::vetFrameGrey(vetFrameRGB96& img) [CONTRUCTOR]")

        data = NULL;
        reAllocCanvas(img.width, img.height);
        *this << img;

        DEBUG(width)
        DEBUG(height)
 }

vetFrameGrey::vetFrameGrey(vetFrameRGBA32& img)
 {
        INFO("vetFrameGrey::vetFrameGrey(vetFrameRGB32& img) [CONTRUCTOR]")

        data = NULL;
        reAllocCanvas(img.width, img.height);
        *this << img;

        DEBUG(width)
        DEBUG(height)
 }


vetFrameGrey::~vetFrameGrey()
{
        if ( data != NULL )
            delete [] data;

        INFO("vetFrameGrey::~vetFrameGrey() [DESTRUCTOR]")
}

VETRESULT vetFrameGrey::reAllocCanvas(unsigned int w, unsigned int h)
 {
        if (data != NULL)
                delete [] data;

        height = h;
        width = w;
        data = NULL;

        if ( width == 0 || height == 0)
                return VETRET_PARAM_ERR;

        data = new PixelGrey[w * h];

        return VETRET_OK;
 }

VETRESULT vetFrameGrey::extractBrightness(unsigned char* buffer, unsigned int* size)
 {
        if (width == 0 || height == 0 || data == NULL)
                return VETRET_ILLEGAL_USE;

        if (buffer == NULL)
         {
                 if ( size == NULL)
                        return VETRET_PARAM_ERR;

                 *size = width*height;
                 return VETRET_OK;
         }

        memcpy (data, buffer, width*height);
        return VETRET_OK;
 }

VETRESULT vetFrameGrey::setWhite()
 {
        if (width == 0 || height == 0 || data == NULL)
                return VETRET_ILLEGAL_USE;

        memset(data, 255, width * height);
        return VETRET_OK;
 }

VETRESULT vetFrameGrey::setBlack()
 {
        if (width == 0 || height == 0 || data == NULL)
                return VETRET_ILLEGAL_USE;

        memset(data, 0, width * height);

        return VETRET_OK;
 }

VETRESULT vetFrameGrey::setPixel(unsigned int x, unsigned int y, PixelGrey level)
{
        // Check that co-ords are valid.
        if ( x >= width || y >= height )
                return VETRET_PARAM_ERR;

        data[y * width + x]  = level;

        return VETRET_OK;
}

VETRESULT vetFrameGrey::setPixel(unsigned int x, unsigned int y, PixelRGB24 p)
 {
        // Check that co-ords are valid.
        if ( x >= width || y >= height )
                return VETRET_PARAM_ERR;


        data[y * width + x] = (PixelGrey)((RED_COEF*(float)p[0]) +
                                                                                        (GREEN_COEF*(float)p[1]) +
                                                                                        (BLUE_COEF*(float)p[2])         );
        return VETRET_OK;
 }

VETRESULT vetFrameGrey::getPixel(unsigned int x, unsigned int y, PixelGrey& p) const
{
        // Check that co-ords are valid.
        if ( x >= width || y >= height )
                return VETRET_PARAM_ERR;

        p = data[y * width + x];
        return VETRET_OK;
}


const PixelGrey& vetFrameGrey::getPixel(unsigned int x, unsigned int y) const
{
        // Check that co-ords are valid.
        if ( x >= width || y >= height )
                throw "Invalid Coordinates in method vetFrameRGB::getPixel(unsigned int x, unsigned int y, PixelGrey p)";

        return data[y * width + x];
}


vetFrameGrey& vetFrameGrey::clearWith(PixelGrey p)
{
        DEBUGMSG("vetFrameGrey& vetFrameGrey::clearWith(PixelGrey p)", p)

    PixelGrey *piter = data;

    for(unsigned int i=0; i < width * height; i++, piter++)
                *piter = p;

        return *this;
}

VETRESULT vetFrameGrey::setWidth(unsigned int newWidth)
 {
        if ( width != 0)
                return VETRET_ILLEGAL_USE;

        width = newWidth;

        return VETRET_OK;
 }

VETRESULT vetFrameGrey::setHeight(unsigned int newHeight)
 {
        if ( height != 0)
                return VETRET_ILLEGAL_USE;

        height = newHeight;

        return VETRET_OK;
 }

vetFrameGrey& vetFrameGrey::copy(vetFrameGrey& img)
{
        /* check we're not trying to copy ourself */
        if (this == &img)
                throw "Source and Destination are same Image";

        /* First check images are the same size and valid */
        if (width  != img.width || height != img.height)
                throw "Difference in image dimensions";

        /* Perform copy */
        memcpy(data, img.data, width * height * sizeof(int));

        return *this;
}


vetFrameGrey& vetFrameGrey::operator += (PixelGrey offset)
{
        INFO("vetFrameGrey& vetFrameGrey::operator += (PixelGrey offset)")

    PixelGrey *piter = data;

    for(unsigned int i=0; i < width * height; i++, piter++)
                *piter += offset;

    return *this;
}

vetFrameGrey& vetFrameGrey::operator -= (PixelGrey offset)
{
        INFO("vetFrameGrey& vetFrameGrey::operator -= (PixelGrey offset)")

    PixelGrey *piter = data;

    for(unsigned int i=0; i < width * height; i++, piter++)
                *piter -= offset;

    return *this;
}

vetFrameGrey& vetFrameGrey::operator *= (float factor)
{
        INFO("vetFrameGrey& vetFrameGrey::operator *= (float factor)")

    PixelGrey *piter = data;

    for(unsigned int i=0; i < width * height; i++, piter++)
                *piter = (int)( ( (float) *piter ) * factor );

    return *this;
}

vetFrameGrey& vetFrameGrey::operator /= (float factor)
{
        INFO("vetFrameGrey& vetFrameGrey::operator /= (float factor)")

    PixelGrey *piter = data;

    for(unsigned int i=0; i < width * height; i++, piter++)
                *piter = (int)(( (float) *piter ) / factor );

    return *this;
}

vetFrameGrey& vetFrameGrey::operator += (vetFrameGrey& img)
{
        INFO("vetFrameGrey& vetFrameGrey::operator += (vetFrameGrey& img)")

        if (width != img.width || height != img.height)
                throw "Difference in vetFrameRGB Dimensions";

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

    return *this;
}

vetFrameGrey& vetFrameGrey::operator -= (vetFrameGrey& img)
{
        INFO("vetFrameGrey& vetFrameGrey::operator -= (vetFrameGrey& img)")

        if (width != img.width || height != img.height)
                throw "Difference in vetFrameRGB Dimensions";

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

    return *this;
}


VETRESULT vetFrameGrey::invert()
{
        INFO("void vetFrameGrey::absolute()")

    PixelGrey *piter = data;
    for(unsigned int i=0; i < width * height; i++, piter++)
        *piter = 255 - *piter;

    return VETRET_OK;
}

VETRESULT vetFrameGrey::threshold(PixelGrey thresh)
{
    PixelGrey *piter = data;

    for(unsigned int i=0; i < width * height; i++, piter++)
                if ( *piter < thresh )
                        *piter = 0;
                else
                        *piter = 255;

    return VETRET_OK;
}

vetFrameGrey& vetFrameGrey::operator >> (vetFrameYUV420& img)
{
        INFO("vetFrameGrey& vetFrameGrey::operator >> (vetFrameYUV420& img) [pushing data]")

        if ( width == 0 || height == 0 )
                throw "Cannot do that with empty image (no size)";

        if ( width != img.width || height != img.height)
                img.reAllocCanvas(width, height);

        //valid cos pixelgrey is uchar
        memcpy(img.data, data, width * height);
        memset(img.U, '\0', width * height / 2); // u+v set to 0

//      img.setBlack();
//      const unsigned int size = width * height;
//      for (unsigned int i=0; i < size; i++)
//              img.data[i] = (unsigned char)( data[i] );
        return *this;
 }

vetFrameGrey& vetFrameGrey::operator >> (vetFrameRGB24& img)
{
        INFO("vetFrameGrey& vetFrameGrey::operator >> (vetFrameRGB24& img) [pushing data]")

        if ( width == 0 || height == 0 )
                throw "Cannot do that with empty image (no size)";

        if ( width != img.width || height != img.height)
                img.reAllocCanvas(width, height);

        const unsigned int size = width * height;
        for (unsigned int i=0; i < size; i++)
         {
                img.data[i][0] = data[i];
                img.data[i][1] = data[i];
                img.data[i][2] = data[i];
         }

        return *this;
 }

vetFrameGrey& vetFrameGrey::operator >> (vetFrameRGB96& img)
{
        INFO("vetFrameGrey& vetFrameGrey::operator >> (vetFrameRGB& img) [pushing data]")


        if ( width == 0 || height == 0 )
                throw "Cannot do that with empty image (no size)";

        if ( width != img.width || height != img.height)
                img.reAllocCanvas(width, height);

        const unsigned int size = width * height;
        for (unsigned int i=0; i < size; i++)
         {
                img.data[i][0] = (int) data[i];
                img.data[i][1] = (int) data[i];
                img.data[i][2] = (int) data[i];
         }

        return *this;
 }

vetFrameGrey& vetFrameGrey::operator >> (vetFrameRGBA32& img)
{
        INFO("vetFrameGrey& vetFrameGrey::operator >> (vetFrameRGB& img) [pushing data]")

        if ( width == 0 || height == 0 )
                throw "Cannot do that with empty image (no size)";

        if ( width != img.width || height != img.height)
                img.reAllocCanvas(width, height);

//BUG

        return *this;
 }

void vetFrameGrey::operator << (const vetFrameYUV420& img)
 {
        INFO("void vetFrameGrey::operator << (const vetFrameYUV420& img) [importing data]")

        if ( img.width == 0 || img.height == 0 )
                throw "Cannot do that with empty image (no size)";

        if ( width != img.width || height != img.height)
                reAllocCanvas(img.width, img.height);

        //valid cos pixelgrey is uchar

        memcpy(data, img.data, width * height);

//      const unsigned int size = width * height;
//      for (unsigned int i=0; i < size; i++)
//              data[i] = (PixelGrey)( img.data[i] );

 }

void vetFrameGrey::operator << (const vetFrameRGB24& img)

 {
        INFO("void vetFrameGrey::operator << (const vetFrameRGB24& img) [importing data]")

        if ( img.width == 0 || img.height == 0 )
                throw "Cannot do that with empty image (no size)";

        if ( width != img.width || height != img.height)
                reAllocCanvas(img.width, img.height);

        const unsigned int size = width * height;
        for (unsigned int i=0; i < size; i++)
                data[i]  = (PixelGrey) (        (RED_COEF  *(float) img.data[i][0])     +
                                                                        (GREEN_COEF*(float) img.data[i][1])     +
                                                                        (BLUE_COEF *(float) img.data[i][2])     );
 }



void vetFrameGrey::operator << (const vetFrameRGB96& img)
 {
        INFO("void vetFrameGrey::operator << (const vetFrameRGB96& img) [importing data]")

        if ( img.width == 0 || img.height == 0 )
                throw "Cannot do that with empty image (no size)";

        if ( width != img.width || height != img.height)
                reAllocCanvas(img.width, img.height);

        const unsigned int size = width * height;
        for (unsigned int i=0; i < size; i++)
                data[i]  = (PixelGrey) (        (RED_COEF  *(float) img.data[i][0])     +
                                                                        (GREEN_COEF*(float) img.data[i][1])     +
                                                                        (BLUE_COEF *(float) img.data[i][2])     );
 }

void vetFrameGrey::operator << (const vetFrameRGBA32& img)
 {
        INFO("void vetFrameGrey::operator << (const vetFrameRGB24& img) [importing data]")

        if ( img.width == 0 || img.height == 0 )
                throw "Cannot do that with empty image (no size)";

        if ( width != img.width || height != img.height)
                reAllocCanvas(img.width, img.height);

//BUG
 }

---