vetFrameRGB96.cpp

Go to the documentation of this file.

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

vetFrameRGB96::vetFrameRGB96() : vetFrame()
 {
        INFO("vetFrameRGB96::vetFrameRGB96() : vetFrame() [CONTRUCTOR]")
        data = NULL;
        width = 0;
        height = 0;
 }

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

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


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

        *this = img;

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


vetFrameRGB96::vetFrameRGB96(vetFrameRGB24& img)
 {
        data = NULL;
        reAllocCanvas(img.width, img.height);

        *this << img;

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

vetFrameRGB96::vetFrameRGB96(vetFrameRGBA32& img)
 {
        data = NULL;
        reAllocCanvas(img.width, img.height);

        *this << img;

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


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

        if ( autoFreeData && data != NULL )
                delete [] data;
}

VETRESULT vetFrameRGB96::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 PixelRGB96[width * height];

        return VETRET_OK;
 }

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

        memset(data, '\0', width * height * sizeof(PixelRGB96) );

        return VETRET_OK;
 }

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

        memset(data, 255, width * height  * sizeof(PixelRGB96) );

        return VETRET_OK;
 }


VETRESULT vetFrameRGB96::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;
         }

        return VETRET_NOT_IMPLEMENTED;
 }

VETRESULT vetFrameRGB96::setPixel(unsigned int x, unsigned int y, PixelRGB96 p)
{
        // Check that co-ords are valid.
        if ( x >= width || y >= height )
                throw "Invalid Coordinates in method vetFrameRGB96::setPixel(unsigned int x, unsigned int y, PixelRGB96 p)";

        data[y * width + x] = p;

        return VETRET_OK;
}


VETRESULT vetFrameRGB96::setRGB(unsigned int x, unsigned int y, int red, int green, int blue)
{
        // Check that co-ords are valid.
        if ( x >= width || y >= height )
                throw "Invalid Coordinates in method vetFrameRGB96::setRGB(unsigned int x, unsigned int y, int red, int green, int blue)";

        unsigned int offset = y * width + x;

        data[offset][RED]   = red;
        data[offset][GREEN] = green;
        data[offset][BLUE]  = blue;

        return VETRET_OK;
 }


VETRESULT vetFrameRGB96::setChannel(unsigned int x, unsigned int y, ChannelRGB fs, int value)
{
        // Check that co-ords are valid.
        if ( x >= width || y >= height )
                throw "Invalid Coordinates in method vetFrameRGB96::setChannel(unsigned int x, unsigned int y, ChannelRGB fs, int value)";

        unsigned int offset = y * width + x;
        data[offset][fs] = value;

        return VETRET_OK;
 }



VETRESULT vetFrameRGB96::getPixel(unsigned int x, unsigned int y, PixelRGB96& p) const
{
        // Check that co-ords are valid.
        if ( x >= width || y >= height )
                throw "Invalid Coordinates in method vetFrameRGB96::setChannel(unsigned int x, unsigned int y, ChannelRGB fs, int value)";

        unsigned int offset = y * width + x;

        p[ RED ] = data[offset][RED];
        p[GREEN] = data[offset][GREEN];
        p[ BLUE] = data[offset][BLUE];

        return VETRET_OK;
 }

const PixelRGB96& vetFrameRGB96::getPixel(unsigned int x, unsigned int y) const
{
        // Check that co-ords are valid.
        if ( x >= width || y >= height )
                throw "Invalid Coordinates in method vetFrameRGB96::setChannel(unsigned int x, unsigned int y, ChannelRGB fs, int value)";

        return data[y * width + x];

}



VETRESULT vetFrameRGB96::getChannel(unsigned int x, unsigned int y, ChannelRGB fs) const
{
        // Check that co-ords are valid.
        if ( x >= width || y >= height )
                throw "Invalid Coordinates in method vetFrameRGB96::setChannel(unsigned int x, unsigned int y, ChannelRGB fs, int value)";

        unsigned int offset = y * width + x;
        return data[offset][fs];

        return VETRET_OK;
 }


vetFrameRGB96& vetFrameRGB96::clear(int k)
{
        DEBUGMSG("vetFrameRGB96& vetFrameRGB96::clear(int k)", k)

        int *start = data[0];
        int *end   = start + width * height * 3;

        for (int *d = start; d < end; d++)
                *d = k;

        return *this;
}


vetFrameRGB96& vetFrameRGB96::clearWith(PixelRGB96& p)
{
        DEBUGMSG("vetFrameRGB96& vetFrameRGB96::clearWith(PixelRGB96& p)", p)

        int *start = data[0];
        int *end   = start + width * height * 3;

        for (int *d = start; d < end; d += 3) {
                d[ RED ] = p[ RED ];
                d[GREEN] = p[GREEN];
                d[ BLUE] = p[ BLUE];
        }

        return *this;
}


vetFrameRGB96& vetFrameRGB96::clearChannel(ChannelRGB channel, int color)
{
        INFO("vetFrameRGB96& vetFrameRGB96::clearChannel(ChannelRGB channel, int color)")
        DEBUG(channel)
        DEBUG(color)

        int *start = data[0];
        int *end   = start + width * height * 3;

        for (int *d = start + channel; d < end; d += 3)
                *d = color;

        return *this;
}

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

        width = newWidth;

        return VETRET_OK;
 }

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

        height = newHeight;

        return VETRET_OK;
 }


vetFrameRGB96& vetFrameRGB96::copy(vetFrameRGB96& img)
{
        INFO("vetFrameRGB96& vetFrameRGB96::copy(vetFrameRGB96& 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 vetFrameRGB96 Dimensions";

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

        return *this;
}


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

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

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

    return *this;
}


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

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

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

    return *this;
}

vetFrameRGB96& vetFrameRGB96::operator >> (vetFrameYUV420& img)
{
        INFO("vetFrameRGB96& vetFrameRGB96::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);

//BUG

        return *this;
}

vetFrameRGB96& vetFrameRGB96::operator >> (vetFrameRGB24& img)
{
        INFO("vetFrameRGB96& vetFrameRGB96::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);

        for (unsigned int i = 0; i < width*height; i++)
         {
                img.data[i][RED] = (unsigned char)data[i][RED];
                img.data[i][GREEN] = (unsigned char)data[i][GREEN];
                img.data[i][BLUE] = (unsigned char)data[i][BLUE];
         }

        return *this;
}


vetFrameRGB96& vetFrameRGB96::operator >> (vetFrameRGBA32& img)
{
        INFO("vetFrameRGB96& vetFrameRGB96::operator >> (vetFrameRGB96& 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;
}

vetFrameRGB96& vetFrameRGB96::operator >> (vetFrameGrey& img)
{
        INFO("vetFrameRGB96& vetFrameRGB96::operator >> (vetFrameGrey& 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 vetFrameRGB96::operator << (const vetFrameYUV420& img)
{
        INFO("void vetFrameRGB96::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);

//BUG

}


void vetFrameRGB96::operator << (const vetFrameRGB24& img)
{
        INFO("void vetFrameRGB96::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);

        /* Perform copy */
        for (unsigned int i = 0; i < width*height; i++)
         {
                data[i][RED] = (int)img.data[i][RED];
                data[i][GREEN] = (int)img.data[i][GREEN];
                data[i][BLUE] = (int)img.data[i][BLUE];
         }
}

void vetFrameRGB96::operator << (const vetFrameRGBA32& img)
{
        INFO("void vetFrameRGB96::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);

        unsigned char* R = img.data;
        unsigned char* G = img.data + width*height;
        unsigned char* B = img.data + width*height*2;

        for (unsigned int i=0; i< width*height; i++)
         {
                data[i][0] = *(R++);
                data[i][1] = *(G++);
                data[i][2] = *(B++);
         }
//CHECKBUG

}

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

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

        float cp;
        for (unsigned int i=0; i< width*height; i++)
         {
                cp = (float)img.data[i];
                data[i][0] = (int)(cp / RED_COEF );
                data[i][1] = (int)(cp / GREEN_COEF );
                data[i][2] = (int)(cp / BLUE_COEF );
         }
//CHECKBUG

 }




/****************************************************************************\
 *       Extra doxygen comments and information relating to this file       *
\****************************************************************************/

---