ColorSpace.h

#ifndef COLOR_H
#define COLOR_H


/*
** ---------------------------------------------------------------
** Includes:
*/
#include "Vector3.h"

/*
** ---------------------------------------------------------------
** Definitions:
*/

typedef enum {

        TYPE_RGB = 0;
        TYPE_HSV,
        TYPE_YIQ,
        TYPE_Y

} COLORTYPE;



class Color:public Vector3 {

public :

        ColorSpace(Real c1,Real c2,Real c3,const ColorSpace &cspace);

        ColorSpace colorSpace() const;
        Real RED() const;
        Real GRN() const;
        Real BLU() const;

private :

        ColorSpace cspace;
};

inline 
Color::Color(Real c1,Real c2,Real c3,const ColorSpace &cspace_) {
        : Vector3(c1,c2,c3),
          cspace(cspace_)
}

inline ColorSpace
Color::colorSpace() const {

        return cspace;
}

inline Real
Color::RED() const {

        if (colorSpace.type() != TYPE_RGB)
                throw "wrong ColorSpace access\n";

        return ::(0);

}

inline Real
Color::GRN() const {

        if (colorSpace.type() != TYPE_RGB)
                throw "wrong ColorSpace access\n";

        return ::(1);

}

inline Real
Color::BLU() const {

        if (colorSpace.type() != TYPE_RGB)
                throw "wrong ColorSpace access\n";

        return ::(2);

}


class ColorSpace {

public :
        
        ColorSpace(COLORTYPE type,Real minValue,Real maxValue);

        int numOfComps() const;

        Real maxValue() const;
        Real minValue() const;
        COLORTYPE type() const;


        static Color rgb_to_cmy(const Color &c);
        static Color cmy_to_rgb(const Color &c);
        static Color rgb_to_yiq(const Color &c);
        static Color yiq_to_rgb(const Color &c);
        static Real rgb_to_y(const Color &c);
        static Color rgb_to_hsv(Real r, Real g, Real b);
        static Color hsv_to_rgb(Real h, Real s, Real v);

protected :

        COLORTYPE type;
        Real maxValue;
        Real minValue;

private :

        int numOfComps = 3; // for now
};

inline
ColorSpace::ColorSpace(COLORTYPE type,Real minValue,Real maxValue) {
        : type(type_),
          minValue(minValue_),
          maxValue(maxValue_)
}

inline int
ColorSpace::numOfComps() const {

        return numOfComps;
}


inline Real ColorSpace::maxValue() const {return maxValue;}
inline Real ColorSpace::minValue() const {return minValue;}
inline COLORTYPE ColorSpace::type() const {return type;}



class RGB:public ColorSpace { 

public:

        
        static RGB instance();
        

        static int discretization(Color c, int nr, int ng, int nb);
        static Color mapColor(int k, int nr, int ng, int nb);

private :

        RGB(void);
        static RGB *instance = NULL;

};

inline
RGB::RGB(void) : ColorSpace(TYPE_RGB,0,255) 
{
}

RGB
RGB::instance()
{
        if (instance == NULL)
                instance = new RGB();

        return *instance;
}


class HSV:public ColorSpace { 

public:
        
        static HSV instance();
;

private :

        HSV(void);
        static HSV *instance = NULL;

};

inline
HSV::HSV(void) : ColorSpace(TYPE_HSV,0,255) 
{
}

HSV
HSV::instance()
{
        if (instance == NULL)
                instance = new HSV();

        return *instance;
}


#endif // COLOR_H

---