Color.h

 
#pragma once
 
#if defined(Color_RECURSES)
#error Recursive header files inclusion detected in Color.h
#else // defined(Color_RECURSES)
#define Color_RECURSES
 
#if !defined Color_h
#define Color_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include <boost/lexical_cast.hpp>
#include <algorithm>
#include <array>
 
namespace DGtal
{
 
  // class Color
  class Color
  {
    // ----------------------- Standard services ------------------------------
  public:
 
    ~Color() = default;
 
    // ----------------------- Interface --------------------------------------
  public:
 
    Color( const unsigned int aRgb,
           unsigned char aAlpha = 255 );
 
    Color( const Color &aColor ) = default;
 
    Color( const unsigned char aRedValue,
           const unsigned char  aGreenValue,
           const unsigned char  aBlueValue,
           const unsigned char aAlphaValue = 255 )
      : myRed(aRedValue),myGreen(aGreenValue),myBlue(aBlueValue),myAlpha(aAlphaValue) { }
 
 
    Color( unsigned char aGrayValue,
           unsigned char aAlphaValue = 255 )
      : myRed(aGrayValue),myGreen(aGrayValue), myBlue(aGrayValue), myAlpha(aAlphaValue) { }
 
 
    Color( )
      : myRed(0),myGreen(0),myBlue(0), myAlpha(255)
    {
    }
 
 
    void red( const unsigned char aRedValue );
 
    void green( const unsigned char aGreenValue );
 
    void blue( const unsigned char aBlueValue );
 
    void alpha( const unsigned char aAlphaValue );
 
    unsigned char red() const ;
 
    unsigned char green() const ;
 
    unsigned char blue() const ;
 
    unsigned char alpha() const ;
 
 
    double r() const ;
 
    double g() const ;
 
    double b() const ;
 
    double a() const ;
 
 
    Color& setRGBi( const unsigned char aRedValue,
                   const unsigned char aGreenValue,
                   const unsigned char aBlueValue,
                   const unsigned char aAlphaValue = 255);
    
    Color& setRGBA( DGtal::uint32_t aRGBA );
    
    
    Color& setFromHSV( const double h, const double s, const double v)
    {
      double r,g,b;
      Color::HSVtoRGB(r,g,b,h,s,v);
      return this->setRGBf((float)r,(float)g,(float)b);
    }
    std::array<double, 3> getHSV() const
    {
      double h,s,v;
      Color::RGBtoHSV(h,s,v, this->red(), this->green(), this->blue());
      return {h,s,v};
    }
    
    DGtal::uint32_t getRGB() const;
 
    DGtal::uint32_t getRGBA() const;
 
    
    
 
    bool valid() const;
 
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
 
 
    Color & setRGBf( float red,
                     float green,
                     float blue,
                     float alpha = 1.0 );
 
    bool operator==( const Color & aColor ) const;
 
    bool operator!=( const Color & aColor ) const;
 
    bool operator<( const Color & aColor ) const;
 
    bool operator>( const Color & aColor ) const;
 
    bool operator<=( const Color & aColor ) const;
 
    bool operator>=( const Color & aColor ) const;
 
 
    Color & operator+= ( const Color & v )
    {
      this->myRed = clamp((int)this->myRed + (int)v.myRed);
      this->myBlue =  clamp((int)this->myBlue + (int)v.myBlue);
      this->myGreen =  clamp((int)this->myGreen + (int)v.myGreen);
#ifdef COLOR_WITH_ALPHA_ARITH
      this->myAlpha =  clamp((int)this->myAlpha + (int)v.myAlpha);
#endif
      return *this;
    }
 
    Color operator+ ( const Color & v ) const
    {
      Color c;
      c.myRed = clamp((int)this->myRed + (int)v.myRed);
      c.myBlue =clamp((int)this->myBlue + (int)v.myBlue);
      c.myGreen = clamp((int)this->myGreen + (int)v.myGreen);
#ifdef COLOR_WITH_ALPHA_ARITH
      c.myAlpha = clamp((int)this->myAlpha + (int)v.myAlpha);
#else
      c.myAlpha = this->myAlpha ;
#endif
  return c;
    }
 
    Color & operator-= ( const Color & v )
    {
      this->myRed = clamp((int)this->myRed - (int)v.myRed);
      this->myBlue = clamp((int)this->myBlue - (int)v.myBlue);
      this->myGreen = clamp((int)this->myGreen - (int)v.myGreen);
#ifdef COLOR_WITH_ALPHA_ARITH
      this->myAlpha = clamp((int)this->myAlpha - (int)v.myAlpha);
#endif
      return *this;
    }
 
    Color operator- ( const Color & v ) const
    {
      Color c;
      c.myRed = clamp((int)this->myRed - (int)v.myRed);
      c.myBlue = clamp((int)this->myBlue - (int)v.myBlue);
      c.myGreen = clamp((int)this->myGreen - (int)v.myGreen);
#ifdef COLOR_WITH_ALPHA_ARITH
      c.myAlpha = clamp((int)this->myAlpha - (int)v.myAlpha);
#else
      c.myAlpha = this->myAlpha ;
#endif
      return c;
    }
 
    Color &operator *= ( const double coeff)
    {
      this->myRed = clamp((double)this->myRed*coeff);
      this->myBlue = clamp((double)this->myBlue*coeff);
      this->myGreen = clamp((double)this->myGreen*coeff);
#ifdef COLOR_WITH_ALPHA_ARITH
      this->myAlpha =  clamp((double)this->myAlpha*coeff);
#endif
      return *this;
    }
 
    Color operator * ( const double coeff) const
    {
      Color c;
      c.myRed = clamp((double)this->myRed*coeff);
      c.myBlue = clamp((double)this->myBlue*coeff);
      c.myGreen = clamp((double)this->myGreen*coeff);
#ifdef COLOR_WITH_ALPHA_ARITH
      c.myAlpha =  clamp((double)this->myAlpha*coeff);
#else
      c.myAlpha  = this->myAlpha;
#endif
      return c;
    }
 
    Color & operator= ( const Color & pv ) = default;
 
    void flushPostscript( std::ostream & ) const;
 
    std::string svg() const;
 
    std::string svgAlpha( const char * aPrefix ) const;
 
    std::string postscript() const;
 
    std::string tikz() const;
 
    static const Color None;
    static const Color Black;
    static const Color Gray;
    static const Color White;
    static const Color Red;
    static const Color Green;
    static const Color Lime;
    static const Color Blue;
    static const Color Cyan;
    static const Color Magenta;
    static const Color Yellow;
    static const Color Silver;
    static const Color Purple;
    static const Color Navy;
    static const Color Aqua;
 
    // ------------------------- Protected Datas ------------------------------
  private:
 
    // ------------------------- Private Datas --------------------------------
  private:
    unsigned char myRed;      
    unsigned char myGreen;    
    unsigned char myBlue;      
    unsigned char myAlpha;    
    // ------------------------- Hidden services ------------------------------
  protected:
 
 
  private:
 
    unsigned char clamp(const double value)  const
    {
      return static_cast<unsigned char>(std::max( std::min(value, 255.0), 0.0));
    }
    
 
    // ----------------------- Static methods ---------------------------------
  public: 
    static void HSVtoRGB(double &r, double &g, double &b,
       double h, const double s, const double v);
 
    static void RGBtoHSV( double & h, double & s, double & v,
        const unsigned char r,
        const unsigned char g,
        const unsigned char b );
 
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class Color
 
 
 
  Color
  operator*( const double coeff,
             const Color &aColor );
 
 
 
  std::ostream&
  operator<< ( std::ostream & out, const Color & aColor );
 
 
} // namespace DGtal
 
 
// Includes inline functions/methods
#include "DGtal/io/Color.ih"
 
 
//                                                                           //
 
#endif // !defined Color_h
 
#undef Color_RECURSES
#endif // else defined(Color_RECURSES)