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>  

namespace DGtal
{

  // class Color
  class Color
  {
    // ----------------------- Standard services ------------------------------
  public:

    ~Color();

    // ----------------------- Interface --------------------------------------
  public:

    Color( const unsigned int aRgb,
           unsigned char aAlpha = 255 );

    Color( const Color &aColor ):
      myRed(aColor.myRed),myGreen(aColor.myGreen),
      myBlue(aColor.myBlue), myAlpha(aColor.myAlpha)
    {}

    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)
    {
    }
    
    Color& setRGBi( const unsigned char aRedValue,
                    const unsigned char aGreenValue,
                    const unsigned char aBlueValue,
                    const unsigned char aAlphaValue );

    Color& setRGBA( DGtal::uint32_t aRGBA );
    
    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 ;


    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;

    
    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 )
    {
      this->myRed = pv.myRed;
      this->myGreen = pv.myGreen;
      this->myBlue = pv.myBlue;
      this->myAlpha = pv.myAlpha;
      return *this;
    }
    

    
    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));
    }



    // ------------------------- 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)