---

ImageHSV.cpp

Go to the documentation of this file.

/**************************************************************************
 *
 * Source code for Real Time Image Library (libRTImage)
 *
 * Leeds Vision Group give permission for this code to be copied, modified
 * and distributed within the University of Leeds subject to the following
 * conditions:-
 *
 * - The code is not to be used for commercial gain.
 * - The code and use thereof will be attributed to the author where
 *   appropriate (inluding demonstrations which rely on it's use).
 * - All modified, distributions of the source files will retain this header.
 *
 ****************************************************************************/

#include <math.h>
#include <ImageHSV.h>

ImageHSV::ImageHSV(ImageRGB& img) : ImageBase(img), ImageRGB(img) 
{
    rgb2hsv() ; 
}

ImageHSV::ImageHSV(ImageRGB& img,
                   unsigned int min_x,
                   unsigned int min_y,
                   unsigned int max_x,
                   unsigned int max_y) : 
                                      ImageRGB(img, min_x, min_y, max_x,max_y),
                                      ImageBase(max_x-min_x+1, max_y-min_y+1)
{
    rgb2hsv() ; 
}

ImageHSV::ImageHSV(ImageHSV& img,
                   unsigned int min_x,
                   unsigned int min_y,
                   unsigned int max_x,
                   unsigned int max_y) : 
                                      ImageRGB(img, min_x, min_y, max_x,max_y),
                                      ImageBase(max_x-min_x+1, max_y-min_y+1)
{
}



void ImageHSV::rgb2hsv()
{
    unsigned int cnt ;
    PixelHSV     hsv ;
    PixelRGB     *rgb ;

    rgb = data ;
    for(cnt=0 ; cnt<width*height ; cnt++, rgb++){
        convPixel_RGBtoHSV(*rgb, hsv) ;
        *rgb = hsv ;
    }
}

void ImageHSV::hsv2rgb() 
{
    unsigned int cnt ;
    PixelHSV     *hsv ;
    PixelRGB     rgb ;

    hsv = data ;
    for(cnt=0 ; cnt<width*height ; cnt++, hsv++){
        convPixel_HSVtoRGB(*hsv, rgb) ;
        *hsv = rgb ;
    }
}

void ImageHSV::convPixel_RGBtoHSV (PixelRGB& rgb, PixelHSV& hsv)
{
    float r = rgb[RED  ] / 255.0;
    float g = rgb[GREEN] / 255.0;
    float b = rgb[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[0] = int (h);
    hsv[1] = int (s * 255);
    hsv[2] = int (v * 255);

}

void ImageHSV::convPixel_HSVtoRGB (PixelHSV& hsv, PixelRGB& rgb)
{
    int i;
    float f, p, q, t, hTemp;

    float h = hsv[0];
    float s = hsv[1] / 255.0;
    float v = hsv[2] / 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);

}

---