GradientColorMap.h

#pragma once

#if defined(GradientColorMap_RECURSES)
#error Recursive header files inclusion detected in GradientColorMap.h
#else // defined(GradientColorMap_RECURSES)

#define GradientColorMap_RECURSES

#if !defined GradientColorMap_h

#define GradientColorMap_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "Board/Board.h"
#include "DGtal/io/Color.h"

#ifndef DGTAL_RGB2INT
#define DGTAL_RGB2INT(R,G,B) (((R)<<16)|((G)<<8)|(B))
#define DGTAL_RED_COMPONENT(I) (((I)>>16)&0xFF)
#define DGTAL_GREEN_COMPONENT(I) (((I)>>8)&0xFF)
#define DGTAL_BLUE_COMPONENT(I) ((I)&0xFF)
#endif

namespace DGtal
{

  // ----------------------- Related enumerations -----------------------------
  enum ColorGradientPreset { CMAP_CUSTOM = 0,
           CMAP_GRAYSCALE,
           CMAP_SPRING,
           CMAP_SUMMER,
           CMAP_AUTUMN,
           CMAP_WINTER,
           CMAP_COOL,
           CMAP_COPPER,
           CMAP_HOT,
           CMAP_JET };

  // template class GradientColorMap
  template <typename PValue, 
    int PDefaultPreset = CMAP_CUSTOM,
    int PDefaultFirstColor = -1,
    int PDefaultLastColor = -1 >
  class GradientColorMap
  {

  public:
    
    typedef PValue Value;

    // ----------------------- Standard services ------------------------------
  public:

    GradientColorMap( const PValue & min,
          const PValue & max,
          const ColorGradientPreset preset
          = static_cast<ColorGradientPreset>( PDefaultPreset ),
          const Color firstColor
          = 
          ( PDefaultFirstColor == -1 ) ? Color::None :
          Color( DGTAL_RED_COMPONENT( PDefaultFirstColor ),
            DGTAL_GREEN_COMPONENT( PDefaultFirstColor ),
            DGTAL_BLUE_COMPONENT( PDefaultFirstColor ) ),
          const Color lastColor
          = 
          ( PDefaultFirstColor == -1 ) ? Color::None :
          Color( DGTAL_RED_COMPONENT( PDefaultLastColor ),
            DGTAL_GREEN_COMPONENT( PDefaultLastColor ),
            DGTAL_BLUE_COMPONENT( PDefaultLastColor ) )
          );
    
    Color operator()( const PValue & value ) const;
      
    ~GradientColorMap();

    GradientColorMap ( const GradientColorMap & other );

    GradientColorMap & operator= ( const GradientColorMap & other );

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

    void clearColors();

    void addColor( const Color & color );

    void selfDisplay ( std::ostream & out ) const;

    bool isValid() const;

    const PValue & min() const;

    const PValue & max() const;

    // ----------------------- Static methods ---------------------------------

    static Color getColor( const std::vector<Color> & colors,
             const PValue & min,
             const PValue & max,
             const PValue & value );
    
    // ------------------------- Protected Datas ------------------------------
  private:

    // ------------------------- Private Datas --------------------------------
  private:

    // ------------------------- Hidden services ------------------------------
  protected:

    PValue myMin;    
    PValue myMax;           
    std::vector<Color> myColors;  
    GradientColorMap();

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


  }; // end of class GradientColorMap

  template <typename PValue,
    int PDefaultPreset,
    int PDefaultFirstColor,
    int PDefaultLastColor >
  std::ostream&
  operator<< ( std::ostream & out, const GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor> & object );
  
} // namespace DGtal


// Includes inline functions.
#include "DGtal/io/colormaps/GradientColorMap.ih"

//                                                                           //

#endif // !defined GradientColorMap_h

#undef GradientColorMap_RECURSES
#endif // else defined(GradientColorMap_RECURSES)