vetFrameHSV.cpp

Go to the documentation of this file.

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

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

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

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

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


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

        *this << img;

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

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

        *this << img;

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


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

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


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

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

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

        return VETRET_OK;
 }

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

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

        return VETRET_OK;
 }

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

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

        return VETRET_OK;
 }


VETRESULT vetFrameHSV::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 vetFrameHSV::setPixel(unsigned int x, unsigned int y, PixelHSV p)
{
        // Check that co-ords are valid.
        if ( x >= width || y >= height )
                throw "Invalid Coordinates in method vetFrameHSV::setPixel(unsigned int x, unsigned int y, PixelHSV p)";

        data[y * width + x] = p;

        return VETRET_OK;
}


VETRESULT vetFrameHSV::setHSV(unsigned int x, unsigned int y, unsigned short int hue, unsigned char sat, unsigned char val)
{
        // Check that co-ords are valid.
        if ( x >= width || y >= height )
                throw "Invalid Coordinates in method vetFrameHSV::setHSV(unsigned int x, unsigned int y, int hue, int sat, int val)";

        unsigned int offset = y * width + x;

        data[offset].hue = hue;
        data[offset].sat = sat;
        data[offset].val = val;

        return VETRET_OK;
}


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


        if (fs == HUE)
                data[y * width + x].hue = value;
        else if (fs == SAT)
                data[y * width + x].sat = (unsigned char)value;
        else if (fs == VAL)
                data[y * width + x].val = (unsigned char)value;
        else
                return VETRET_PARAM_ERR;

        return VETRET_OK;
}


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

        p = data[y * width + x];

        return VETRET_OK;
}


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

        if (fs == HUE)
                return (unsigned int)data[y * width + x].hue;
        else if (fs == SAT)
                return (unsigned int)data[y * width + x].sat;
        else if (fs == VAL)
                return (unsigned int)data[y * width + x].val;

        throw "Unknown Channel in method vetFrameHSV::setChannel(unsigned int x, unsigned int y, ChannelHSV fs, int value)";
}


vetFrameHSV& vetFrameHSV::clearWith(PixelHSV& p)
{
        DEBUGMSG("vetFrameHSV& vetFrameHSV::clearWith(PixelHSV& p)", p)

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

        return *this;
}


vetFrameHSV& vetFrameHSV::clearChannel(ChannelHSV fs, unsigned int value)
{
        INFO("vetFrameHSV& vetFrameHSV::clearChannel(ChannelHSV channel, unsigned int value)")
        DEBUG(channel)
        DEBUG(color)


        if (fs == HUE)
        {
                for (unsigned int i = 0; i<width*height; i++)
                        data[i].hue = value;
        }
        else if (fs == SAT)
        {
                for (unsigned int i = 0; i<width*height; i++)
                        data[i].sat = (unsigned char)value;
        }
        else if (fs == VAL)
        {
                for (unsigned int i = 0; i<width*height; i++)
                        data[i].val = (unsigned char)value;
        }

        return *this;
}



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

        width = newWidth;

        return VETRET_OK;
 }

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

        height = newHeight;

        return VETRET_OK;
 }


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

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

        return *this;
}


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

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

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

    return *this;
}


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

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

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

    return *this;
}


vetFrameHSV& vetFrameHSV::operator /= (vetFrameHSV& img)
{
        INFO("vetFrameHSV& vetFrameHSV::operator /= (vetFrameHSV& img)")

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

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

    return *this;
}


vetFrameHSV& vetFrameHSV::operator *= (vetFrameHSV& img)
{
        INFO("vetFrameHSV& vetFrameHSV::operator *= (vetFrameHSV& img)")

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

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

    return *this;
}



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

    for(unsigned int cnt=0 ; cnt<width*height ; cnt++)
                convPixel_HSVtoRGB24(data[cnt], img.data[cnt]);
//CHECKBUGS


        return *this;
}

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

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

        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);

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

        return *this;
}

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


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

        return *this;
}

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

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

        return *this;
}



void vetFrameHSV::operator << (const vetFrameRGB24& img)
{
        INFO("void vetFrameHSV::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= height*width;
        for (unsigned int i=0; i < size; i++)
        convPixel_RGB24toHSV(img.data[i], data[i]);

}


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

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

        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);

        memcpy(data, img.data, width * height * sizeof(PixelHSV));
}

void vetFrameHSV::operator << (const vetFrameRGB96& img)
{
        INFO("void vetFrameHSV::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= height*width;
        for (unsigned int i=0; i < size; i++)
        convPixel_RGB32toHSV(img.data[i], data[i]);

 }

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

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


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

 }

















void vetFrameHSV::convPixel_RGB32toHSV (const PixelRGB96& rgb, PixelHSV& hsv)
{
    float r = rgb[vetFrameRGB96::RED  ] / 255.0;
    float g = rgb[vetFrameRGB96::GREEN] / 255.0;
    float b = rgb[vetFrameRGB96::BLUE ] / 255.0;

    float h, s, v;

    float mn = r, mx = r;
    int maxVal = 0;

    if (g > mx) { mx = g; maxVal = 1; }
    if (b > mx) { mx = b; maxVal = 2; }
    if (g < mn) mn = g;
    if (b < mn) mn = b;

    float  delta = mx - mn;

    v = mx;
    if (mx != 0)
        s = delta / mx;
    else {
        s = 0;
        h = 0;
        goto ass_end;
    }

    if (s == 0.0f) {
        h = 0; // Arbritrary
        goto ass_end;
    } else {
        switch (maxVal)
        {
            case 0: h = 0 + ( g - b ) / delta; break;     // yel  < h < mag
            case 1: h = 2 + ( b - r ) / delta; break;     // cyan < h < yel
            case 2: h = 4 + ( r - g ) / delta; break;     // mag  < h < cyan
            default: h = 0 ; break ; // Should never occur
        }
    }

    h *= 60;
    if (h < 0) h += 360;

ass_end:    // the assignments at the end of the function ;-)

    hsv.hue = int (h);
    hsv.sat = int (s * 255);
    hsv.val = int (v * 255);

}

void vetFrameHSV::convPixel_HSVtoRGB32 (const PixelHSV& hsv, PixelRGB96& rgb)
{
    int i;
    float f, p, q, t, hTemp;

    float h = hsv.hue;
    float s = hsv.sat / 255.0;
    float v = hsv.val / 255.0;

    float r, g, b;

    if (s == 0.0 || h == -1.0) { // s==0? Totally unsaturated = grey
        rgb[0] = rgb[1] = rgb[2] = (int) v * 255;
    }
    hTemp = h / 60.0f;
    i = (int) floor(hTemp);                 // which sector
    f = hTemp - i;                      // how far through sector
    p = v * ( 1 - s );
    q = v * ( 1 - s * f );
    t = v * ( 1 - s * ( 1 - f ) );

    switch (i) {
        case 0: r = v; g = t; b = p; break;
        case 1: r = q; g = v; b = p; break;
        case 2: r = p; g = v; b = t; break;
        case 3: r = p; g = q; b = v; break;
        case 4: r = t; g = p; b = v; break;
        case 5: r = v; g = p; b = q; break;
        default: r=0 ; g=0 ; b=0 ; break ; // Should never occur
    }

    rgb[0] = int (r * 255);
    rgb[1] = int (g * 255);
    rgb[2] = int (b * 255);

}




void vetFrameHSV::convPixel_RGB24toHSV (const PixelRGB24& rgb, PixelHSV& hsv)
{
    float r = (int)rgb[vetFrameRGB96::RED  ] / 255.0;
    float g = (int)rgb[vetFrameRGB96::GREEN] / 255.0;
    float b = (int)rgb[vetFrameRGB96::BLUE ] / 255.0;

    float h, s, v;

    float mn = r, mx = r;
    int maxVal = 0;

    if (g > mx) { mx = g; maxVal = 1; }
    if (b > mx) { mx = b; maxVal = 2; }
    if (g < mn) mn = g;
    if (b < mn) mn = b;

    float  delta = mx - mn;

    v = mx;
    if (mx != 0)
        s = delta / mx;
    else {
        s = 0;
        h = 0;
        goto ass_end;
    }

    if (s == 0.0f) {
        h = 0; // Arbritrary
        goto ass_end;
    } else {
        switch (maxVal)
        {
            case 0: h = 0 + ( g - b ) / delta; break;     // yel  < h < mag
            case 1: h = 2 + ( b - r ) / delta; break;     // cyan < h < yel
            case 2: h = 4 + ( r - g ) / delta; break;     // mag  < h < cyan
            default: h = 0 ; break ; // Should never occur
        }
    }

    h *= 60;
    if (h < 0) h += 360;

ass_end:    // the assignments at the end of the function ;-)

    hsv.hue = int (h);
    hsv.sat = int (s * 255);
    hsv.val = int (v * 255);

}

void vetFrameHSV::convPixel_HSVtoRGB24 (const PixelHSV& hsv, PixelRGB24& rgb)
{
    int i;
    float f, p, q, t, hTemp;

    float h = hsv.hue;
    float s = hsv.sat / 255.0;
    float v = hsv.val / 255.0;

    float r, g, b;

    if (s == 0.0 || h == -1.0) { // s==0? Totally unsaturated = grey
        rgb[0] = rgb[1] = rgb[2] = (int) v * 255;
    }
    hTemp = h / 60.0f;
    i = (int) floor(hTemp);                 // which sector
    f = hTemp - i;                      // how far through sector
    p = v * ( 1 - s );
    q = v * ( 1 - s * f );
    t = v * ( 1 - s * ( 1 - f ) );

    switch (i) {
        case 0: r = v; g = t; b = p; break;
        case 1: r = q; g = v; b = p; break;
        case 2: r = p; g = v; b = t; break;
        case 3: r = p; g = q; b = v; break;
        case 4: r = t; g = p; b = v; break;
        case 5: r = v; g = p; b = q; break;
        default: r=0 ; g=0 ; b=0 ; break ; // Should never occur
    }

    rgb[0] = (unsigned char)(r * 255);
    rgb[1] = (unsigned char)(g * 255);
    rgb[2] = (unsigned char)(b * 255);

}





void vetFrameHSV::convPixel_GREYtoHSV (const PixelGrey& grey, PixelHSV& hsv)
{
    float r = (int)grey / RED_COEF / 255.0;
    float g = (int)grey / GREEN_COEF / 255.0;
    float b = (int)grey / BLUE_COEF / 255.0;
//CHECKBUGS
    float h, s, v;

    float mn = r, mx = r;
    int maxVal = 0;

    if (g > mx) { mx = g; maxVal = 1; }
    if (b > mx) { mx = b; maxVal = 2; }
    if (g < mn) mn = g;
    if (b < mn) mn = b;

    float  delta = mx - mn;

    v = mx;
    if (mx != 0)
        s = delta / mx;
    else {
        s = 0;
        h = 0;
        goto ass_end;
    }

    if (s == 0.0f) {
        h = 0; // Arbritrary
        goto ass_end;
    } else {
        switch (maxVal)
        {
            case 0: h = 0 + ( g - b ) / delta; break;     // yel  < h < mag
            case 1: h = 2 + ( b - r ) / delta; break;     // cyan < h < yel
            case 2: h = 4 + ( r - g ) / delta; break;     // mag  < h < cyan
            default: h = 0 ; break ; // Should never occur
        }
    }

    h *= 60;
    if (h < 0) h += 360;

ass_end:    // the assignments at the end of the function ;-)

    hsv.hue = int (h);
    hsv.sat = int (s * 255);
    hsv.val = int (v * 255);

}

void vetFrameHSV::convPixel_HSVtoGREY (const PixelHSV& hsv, PixelGrey& grey)
{
    int i;
    float f, p, q, t, hTemp;

    float h = hsv.hue;
    float s = hsv.sat / 255.0;
    float v = hsv.val / 255.0;

    float r, g, b;

    if (s == 0.0 || h == -1.0) { // s==0? Totally unsaturated = grey
        grey = (int) v * 255;
    }
    hTemp = h / 60.0f;
    i = (int) floor(hTemp);                 // which sector
    f = hTemp - i;                      // how far through sector
    p = v * ( 1 - s );
    q = v * ( 1 - s * f );
    t = v * ( 1 - s * ( 1 - f ) );

    switch (i) {
        case 0: r = v; g = t; b = p; break;
        case 1: r = q; g = v; b = p; break;
        case 2: r = p; g = v; b = t; break;
        case 3: r = p; g = q; b = v; break;
        case 4: r = t; g = p; b = v; break;
        case 5: r = v; g = p; b = q; break;
        default: r=0 ; g=0 ; b=0 ; break ; // Should never occur
    }

        grey = (PixelGrey)(r * 255 * RED_COEF + g * 255 * GREEN_COEF + b * 255 * BLUE_COEF);

}






















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

---