Color.cpp

Aller � la documentation de ce fichier.

/// \file 
///     Impl�mentation des classes utiles pour la gestion des couleurs
#include "Color.hpp"
///////////////////////////////////////////////////////////////////////////////
/// Classe : Color
///////////////////////////////////////////////////////////////////////////////
Color::Color(){
        p = new Color_Gray(0);
}
Color::Color(float gray){ 
        p = new Color_Gray(gray);
}
Color::Color(float red, float green, float blue, bool rgb){
        p = new Color_Color(red, green, blue, rgb);
}
Color::Color(const Color& color){
        p = color.p;
        ++p->use;       
}
Color& Color::operator=(const Color& rhs){ 
        rhs.p->use++;
        if(--p->use == 0){
                delete p;       
        }
        p = rhs.p;
        return *this;
}
Color::~Color(){
        if(--p->use == 0){
                delete p;
        }               
}
ECOLOR_TYPE Color::getType()const{
        return p->getType();
}
string Color::toString() const{
        return p->toString();
}
float Color::getGray() const{
        return p->getGray();
}
float Color::getRed() const{
        return p->getRed();
}
float Color::getGreen() const{
        return p->getGreen();
}
float Color::getBlue() const{
        return p->getBlue();
}
float Color::getHue()const{
        return p->getHue();
}
float Color::getSaturation()const{
        return p->getSaturation();
}
float Color::getValue()const{
        return p->getValue();
}
float* Color::getFloat(bool rgb)const{
        float* ret = new float[3];
        if(rgb){
                ret[0] = p->getRed();
                ret[1] = p->getGreen();
                ret[2] = p->getBlue();
        } else {
                ret[0] = p->getHue();
                ret[1] = p->getSaturation();
                ret[2] = p->getValue();
        }
        return ret;
}
float Color::distance(const Color c)const{
        return p->distance(c.p);
}
bool Color::operator<(const Color rhs)const{
        return p->operator<(rhs);
}
bool Color::operator==(const Color rhs)const{
        return p->operator==(rhs);
}
///     .
/// On a une palette de couleurs pr�d�finie et on retourne 
/// cycliquement les couleurs quelles contient. Les valeur de la palettes
/// sont tir�es de la colormap "cool" de Matlab
Color Color::getColor(int i){
        // la palette
        const static float palet[64][3] = {
                {0,0,143.4375}, {0,0,159.375}, {0,0,175.3125}, {0,0,191.25}, {0,0,207.1875}, 
                {0,0,223.125},{0,0,239.0625}, {0,0,255}, {0,15.9375,255}, {0,31.875,255},
                {0,47.8125,255}, {0,63.75,255}, {0,79.6875,255}, {0,95.625,255}, {0,111.5625,255},
                {0,127.5,255}, {0,143.4375,255}, {0,159.375,255}, {0,175.3125,255}, {0,191.25,255},
                {0,207.1875,255}, {0,223.125,255}, {0,239.0625,255}, {0,255,255}, {15.9375,255,239.0625},
                {31.875,255,223.125}, {47.8125,255,207.1875}, {63.75,255,191.25}, {79.6875,255,175.3125},
                {95.625,255,159.375}, {111.5625,255,143.4375}, {127.5,255,127.5}, {143.4375,255,111.5625},
                {159.375,255,95.625}, {175.3125,255,79.6875}, {191.25,255,63.75}, {207.1875,255,47.8125},
                {223.125,255,31.875}, {239.0625,255,15.9375}, {255,255,0}, {255,239.0625,0}, {255,223.125,0},
                {255,207.1875,0}, {255,191.25,0}, {255,175.3125,0}, {255,159.375,0}, {255,143.4375,0},
                {255,127.5,0}, {255,111.5625,0}, {255,95.625,0}, {255,79.6875,0}, {255,63.75,0}, {255,47.8125,0},
                {255,31.875,0}, {255,15.9375,0}, {255,0,0}, {239.0625,0,0}, {223.125,0,0}, {207.1875,0,0},
                {191.25,0,0}, {175.3125,0,0}, {159.375,0,0}, {143.4375,0,0},{127.5,0,0}
        };
        // indexe dans la palette
        int ndx = i % 64 ;
        Color ret(palet[ndx][0], palet[ndx][1], palet[ndx][2], true);
        return ret;
}
Color Color::getAverageColor(Color color1, int size1, Color color2, int size2){
        int total = size1 + size2;
        float h = (size1 * color1.getHue() + size2 * color2.getHue());
        float s = (size1 * color1.getSaturation() + size2 * color2.getSaturation());
        float v = (size1 * color1.getValue() + size2 * color2.getValue());
        h /= total;
        s /= total;
        v /= total;
        Color ret(h, s, v, false);
        return ret;
        
}
bool Color::inWindow(float* color1, float radius, float* color2){
        float deltaV = (color1[2] - color2[2]);
        if(deltaV  < 0){
                deltaV = -deltaV;
        }
        if(deltaV > radius){
                return false;
        }       
        float deltaH = (color1[0] - color2[0]);
        if(deltaH  < 0){
                deltaH = -deltaH;
        }
        if(deltaH > radius){
                return false;
        }       
        float deltaS = (color1[1] - color2[1]);                 
        if(deltaS  < 0){
                deltaS = -deltaS;
        }
        if(deltaS > radius){
                return false;
        }       
        return true;
}
///////////////////////////////////////////////////////////////////////////////
/// Classe : Color_Gray
///////////////////////////////////////////////////////////////////////////////
string Color_Gray::toString() const{
        std::ostringstream o;
        o << "GRAY "    << gray;
        return o.str();
}
///     .
/// Valeur absolue de la diff�rence des niveaux de gris
float Color_Gray::distance(const Color_Base* c)const{
        if(c->getType() != type){
                throw std::runtime_error(" DISTANCE DE COULEURS DE TYPE DIFFERENT ");
        }
        float g = ((Color_Gray*)c)->gray;
        float g1 =  gray;

        float ret = g - g1;

        if(ret < 0){
                ret = -ret;
        }
        ret /= 255.0;
        return ret;
}
///     .
/// Comparaison avec l'autre niveau de gris
bool Color_Gray::operator<(const Color rhs) const{
        bool ret = (gray < rhs.getGray());
        return ret;
}
///     .
/// Egalit� avec l'autre niveau de gris
bool Color_Gray::operator==(const Color rhs) const{
        bool ret = (gray == rhs.getGray());
        return ret;
}
///////////////////////////////////////////////////////////////////////////////
/// Classe : Color_Color
///////////////////////////////////////////////////////////////////////////////

///     .
/// Construit une couleur � partir de 3 valeures flottantes
/// Le param�tre rgb indique si la les composantes sont des valeures RGB ou HSV
/// On calcule imm�diatement la conversion entre RGB et HSV
/// \param f1,f2,f3 les 3 composantes
/// \param rgb indique le type de coordonn�es
Color_Color::Color_Color(float f1, float f2, float f3, bool rgb):Color_Base(COLOR_COLOR){
        if(rgb){
                red = f1;
                green = f2;
                blue = f3;
                // conversion
                _computeHSV();
        }else{
                hue = f1;
                saturation = f2;
                value = f3;
                // conversion
                _computeRGB();
        }
}
string Color_Color::toString() const{
        std::ostringstream o;
        o << "COLOR ["  << red << ":" << green << ":" << blue << "][" << hue << ":" << saturation << ":" << value << "]";
        return o.str();
}
///     .
/// Conversion des coordonn�es cylindriques en coordonn�es
/// cart�siennes et calcule de la norme euclidienne
float Color_Color::distance(const Color_Base* c)const{
        if(c->getType() != type){
                throw std::runtime_error(" DISTANCE DE COULEURS DE TYPE DIFFERENT ");
        }
        Color_Color* col = (Color_Color*)c;
        // coordonn�es cart�siennes de l'instance
        float v1 = value * saturation * cos(2 * Pi * hue);
        float v2 = value * saturation * sin(2 * Pi * hue);
        float v3 = value;
        // coordonn�es cart�siennes de l'autre instance
        float w1 = (col->value) * (col->saturation) * cos(2 * Pi * (col->hue));
        float w2 = (col->value) * (col->saturation) * sin(2 * Pi * (col->hue));
        float w3 = (col->value);
        // norme euclidienne
        float hh = v1 - w1;
        hh *= hh;
        float ss = v2 - w2;
        ss *= ss;
        float vv = v3 - w3;
        vv *= vv;
        float ret = sqrt(hh + ss + vv );
        return ret;

}
///.
///     Conversion RGB->HSV     Algorithme tir� de www.easyrgb.com
void Color_Color::_computeHSV(){
        float min, max, delta;

        float r = (float)red / 255;
        float g = (float)green / 255;
        float b = (float)blue / 255;

        min = (r < g ? r : g);
        min = (b < min ? b : min);

        max = (r > g ? r : g);
        max = (b > max ? b : max);

        delta = max - min;
        value = max;

        if (delta == 0){
                hue = 0;
                saturation = 0;
        } else {
                saturation = delta / max;
                float deltaR = ( ( ( max - r ) / 6 ) + ( delta / 2 ) ) / delta;
                float deltaG = ( ( ( max - g ) / 6 ) + ( delta / 2 ) ) / delta;
                float deltaB = ( ( ( max - b ) / 6 ) + ( delta / 2 ) ) / delta;

                if( r == max ){
                        hue = deltaB - deltaG;
                }else if( g == max ){
                        hue = ( 1.0 / 3.0 ) + deltaR - deltaB;
                }else if( b == max ){
                        hue = ( 2.0 / 3.0 ) + deltaG - deltaR;
                }

                if ( hue < 0 ){
                        hue += 1;
                }
                if ( hue > 1 ){
                        hue -= 1;
                }
        }
}
///.
///     Conversion HSV->RGB     Algorithme tir� de www.easyrgb.com
void Color_Color::_computeRGB(){
        if(saturation == 0){
                red = value * 255;
                green = value * 255;
                blue = value * 255;
        }else{
                float var_h = hue * 6;
                float var_i = int(var_h);
                float var_1 = value * (1 - saturation);
                float var_2 = value * (1 - saturation * (var_h -var_i));
                float var_3 = value * (1 - saturation * (1 - (var_h - var_i)));

                float var_r = 0.0;
                float var_g = 0.0;
                float var_b = 0.0;
                if(var_i == 0){
                        var_r = value;
                        var_g = var_3;
                        var_b = var_1;
                }else if(var_i == 1){
                        var_r = var_2;
                        var_g = value;
                        var_b = var_1;
                }else if(var_i == 2){
                        var_r = var_1;
                        var_g = value;
                        var_b = var_3;
                }else if(var_i == 3){
                        var_r = var_1;
                        var_g = var_2;
                        var_b = value;
                }else if(var_i == 4){
                        var_r = var_3;
                        var_g = var_1;
                        var_b = value;
                }else{
                        var_r = value;
                        var_g = var_1;
                        var_b = var_2;
                }
                red = var_r * 255;
                green = var_g * 255;
                blue = var_b * 255;
        }
}
///     .
/// L'odre utilis� est l'ordre lexicographique : on compare les 
/// composantes HSV des 2 couleurs
bool Color_Color::operator<(const Color rhs) const{
        // composante H
        float h = hue - rhs.getHue();
        if(h < 0){
                return true;
        }
        // si les composantes H sont �gales, on test S
        float s = saturation - rhs.getSaturation();
        if(h == 0 && s < 0){
                return true;
        }
        // si les composantes H et S sont �gales, on test V
        float v = value - rhs.getValue();
        if(h == 0 && s == 0 && v < 0 ){
                return true;
        }
        // sinon l'autre couleur est plus grande
        return false;
}
///     .
/// L'odre utilis� est l'ordre lexicographique : on compare les 
/// composantes HSV des 2 couleurs
bool Color_Color::operator==(const Color rhs) const{
        bool ret = true;

        ret &= (hue == rhs.getHue());
        ret &= (saturation == rhs.getSaturation());
        ret &= (value == rhs.getValue());

        return ret;
}

---