Color.hpp

Aller à la documentation de ce fichier.

/// \file 
///     Définition des classes utiles pour la gestion des couleurs
#ifndef GUARD_COLOR_h
#define GUARD_COLOR_h

#include <string>
#include <sstream>
#include <cmath>
#include <stdexcept>
#include "Debug.hpp"

static Channel channelColor(&cout);
/// Une constante bien connue...
const double Pi = 3.141592;
///////////////////////////////////////////////////////////////////////////////
/// Type de couleur
///
/// 3 type de couleurs : vide pour des besoins d'implémenation, gris et couleur
///////////////////////////////////////////////////////////////////////////////
enum ECOLOR_TYPE{
        COLOR_EMPTY,
        COLOR_GRAY,
        COLOR_COLOR,
};
class Color_Base;
///////////////////////////////////////////////////////////////////////////////
/// Interface sur une classe de couleur concrète
///
/// Gère un compteur de références
/// La pluspart des méthodes sont redirigées vers une instance héritées de
/// Color_Base
///////////////////////////////////////////////////////////////////////////////
class Color{
        /// Pointeur sur une couleur
        Color_Base* p;
public:
        /// Constructeur par défaut, couleur de type : COLOR_EMPTY
        Color();
        /// Constructeur pour une couleur de type : COLOR_GRAY
        Color(float);
        /// Constructeur pour une couleur de type : COLOR_COLOR
        Color(float, float, float, bool);
        /// Constructeur de copie
        Color(const Color&);
        /// Opérateur d'affectation
        Color& operator=(const Color&);
        /// Desctructeur
        ~Color();
        /// Retourne le type de la couleur
        ECOLOR_TYPE getType()const;
        /// Retourne une chaîne de caractères détaillée
        string toString() const;
        /// Retourne le niveau de gris [0:1]
        float getGray() const;
        /// Retourne la composante rouge [0:1]
        float getRed() const;
        /// Retourne la composante verte [0:1]
        float getGreen() const;
        /// Retourne la composante bleue [0:1]
        float getBlue() const;
        /// Retourne la teinte [0:1]
        float getHue()const;
        /// Retourne la saturation [0:1]
        float getSaturation()const;
        /// Retourne la valeur [0:1]
        float getValue()const;
        /// Retourne un table des composantes
        float* getFloat(bool)const;
        /// Retourne la distance d'une couleur à une autre
        float distance(Color)const;
        /// Opérateur relationnel d'égalité
        bool operator==(const Color)const;
        /// Opérateur relationnel d'ordre
        bool operator<(const Color)const;
        /// Retourne une couleur prédéfinie
        static Color getColor(int);
        /// Retourne la moyenne pondérée de 2 couleurs
        /// \param Color première couleur
        /// \param int poids de la première couleur
        /// \param Color seconde couleur
        /// \param vint poids de la seconde couleur
        static Color getAverageColor(Color, int, Color, int);   
        /// Teste l'appartenance à une sphère de couleur
        /// \param float* valeur hsv du centre
        /// \param float rayon de la sphère
        /// \param float* valeur hsv de couleur à tester
        static bool inWindow(float*, float, float*);
};
///////////////////////////////////////////////////////////////////////////////
/// Classe de base abstraite pour les 2 type de couleurs : gris et couleurs
///
/// C'est cette classe qui possède le compteur de référence
///////////////////////////////////////////////////////////////////////////////
class Color_Base{
        friend class Color;
        /// Compteur de références
        int use;
protected:
        /// Type
        ECOLOR_TYPE type;
        /// Construit une couleur avec son type et initialise le compteur de références
        Color_Base(ECOLOR_TYPE _type):use(1), type(_type){}
        /// Retourne une chaîne de caractères détaillés pour le debug
        virtual string toString() const = 0;
        /// Retourne le niveau de gris [0:1]
        virtual float getGray()const = 0;
        /// Retourne la composante rouge [0:1]
        virtual float getRed()const = 0;
        /// Retourne la composante verte [0:1]
        virtual float getGreen()const = 0;
        /// Retourne la composante bleue [0:1]
        virtual float getBlue()const = 0;
        /// Retourne la teinte [0:1]
        virtual float getHue()const = 0;
        /// Retourne la saturation [0:1]
        virtual float getSaturation()const = 0;
        /// Retourne la valeur [0:1]
        virtual float getValue()const = 0;
        /// Retourne la distance entre 2 couleurs
        virtual float distance(const Color_Base*)const = 0;
        /// Opérateur relationnel d'égalité de couleur  
        virtual bool operator==(const Color) const = 0;
        /// Opérateur relationnel d'ordre sur les couleurs
        virtual bool operator<(const Color) const = 0;
public:        
        /// Retourne le type de la couleur      
        ECOLOR_TYPE getType()const{return type;}
};
///////////////////////////////////////////////////////////////////////////////
/// Classe pour les couleurs en niveaux de gris
///////////////////////////////////////////////////////////////////////////////
class Color_Gray : public Color_Base{
        friend class Color;        
        /// Niveau de gris
        float gray;
        /// Construit une couleur à partir d'un niveau de gris [0:255.0]
        Color_Gray(float _gray):Color_Base(COLOR_GRAY), gray(_gray){}
        /// Retourne une chaîne de caractères détaillée
        string toString() const;
        /// Retourne le niveau de gris [0:255]  
        float getGray()const{return gray;}
        /// Retourne la composante rouge = niveau de gris [0:255]       
        float getRed()const{return gray;}
        /// Retourne la composante verte = niveau de gris [0:255]       
        float getGreen()const{return gray;}
        /// Retourne la composante bleue = niveau de gris [0:255]       
        float getBlue()const{return gray;}
        /// Retourne la teinte = 0 [0:1]        
        float getHue()const{return 0;}
        /// Retourne la saturation teinte = 0 [0:1]     
        float getSaturation()const{return 0;}
        /// Retourne la valeur = niveau de gris [0:1]   
        float getValue()const{return gray / 255.0;}
        /// Retourn la distance entre 2 niveaux de gris : valeur absoule de la différence
        float distance(const Color_Base*)const;
        /// Oérateur relationnel d'égalité
        bool operator==(const Color) const;
        /// opérateur relationnel d'ordre
        bool operator<(const Color) const;
};
///////////////////////////////////////////////////////////////////////////////
/// Classe pour les couleurs
///////////////////////////////////////////////////////////////////////////////
class Color_Color : public Color_Base{
        friend class Color;        
        /// Composante rouge
        float red;
        /// Composante verte
        float green;
        /// Composante bleue
        float blue;
        /// Teinte
        float hue;
        /// Saturation
        float saturation;
        /// Valeur
        float value;
        /// Fonction de conversion RGB->HSV
        void _computeHSV();
        /// Fonction de conversion HSV->RGB
        void _computeRGB();
        /// Construit une couleur à partir de 3 valeurs RGB ou 3 valeus HSV (dépend du paramètre booléen)
        Color_Color(float, float, float, bool);
        /// Retourne une chaîne de caractères détaillés pour le debug   
        string toString() const;
        /// Retourne le niveau de gris [0:1] : on fait simplement la moyenne des 3 valeurs      
        float getGray()const{ return (red + green + blue) / 3;}
        /// Retourne la composante rouge [0:1]          
        float getRed()const{return red;}
        /// Retourne la composante verte [0:1]                  
        float getGreen()const{return green;}
        /// Retourne la composante bleue [0:1]                          
        float getBlue()const{return blue;}
        /// Retourne la teinte
        float getHue()const{return hue;}
        /// Retourne la saturation
        float getSaturation()const{return saturation;}
        /// Retourne la valeur
        float getValue()const{return value;}
        /// Distance entre 2 couleurs
        float distance(const Color_Base*)const;
        /// Opérateur relationnel d'égalité
        bool operator==(const Color) const;     
        ///     Opérateur relationnel d'ordre
        bool operator<(const Color)const;
};
#endif

---