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>


namespace DGtal
{

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

    ~Color();

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

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


    Color( unsigned char aRedValue, unsigned char  aGreenValue, unsigned char  aBlueValue,
           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( const bool aValidColor = true )
      : myRed(-1),myGreen(-1),myBlue(-1), myAlpha(255)
    { 
      if ( aValidColor ) {
        myRed = myGreen = myBlue = 0;
      }
    }
    
    Color& setRGBi( const unsigned char aRedValue,
                    const unsigned char aGreenValue,
                    const unsigned char aBlueValue,
                    const unsigned char aAlphaValue );

    
    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 ;

    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;

    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;



    //Color ( const Color & aColor );

    //   Color & operator= ( const Color & aColor );


    // ------------------------- Protected Datas ------------------------------
  private:
    // ------------------------- Private Datas --------------------------------
  private:
    int myRed;      
    int myGreen;    
    int myBlue;      
    int myAlpha;    
    // ------------------------- Hidden services ------------------------------
  protected:


  private:

 



    // ------------------------- Internals ------------------------------------
  private:

  }; // end of class Color


  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)