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,
           CMAP_VIRIDIS};

  // 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,
             PValue value );
 
    // ------------------------- Protected Data ------------------------------
  private:
 
    // ------------------------- Private Data --------------------------------
  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)