GradientColorMap.ih

#include <cstdlib>
#include <vector>

// IMPLEMENTATION of inline methods.

// ----------------------- Standard services ------------------------------

template < typename PValue,
     int PDefaultPreset,
     int PDefaultFirstColor,
     int PDefaultLastColor >
inline
DGtal::GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor>::GradientColorMap
( const PValue & minV,
  const PValue & maxV,
  const ColorGradientPreset preset,
  const Color firstColor,
  const Color lastColor )
  : myMin( minV ), myMax( maxV )
{ 
  switch ( preset ) {
  case CMAP_GRAYSCALE:
    myColors.push_back( Color::Black );
    myColors.push_back( Color::White );
    break;
  case CMAP_SPRING:
    myColors.push_back( Color( 255, 0, 255 ));
    myColors.push_back( Color( 255, 255, 0 ));
    break;
  case CMAP_SUMMER:
    myColors.push_back( Color( 0, 132, 100 ));
    myColors.push_back( Color( 255, 255, 100 ));
    break;
  case CMAP_AUTUMN:
    myColors.push_back( Color( 255, 0, 0 ));
    myColors.push_back( Color( 255, 255, 0));
    break;
  case CMAP_WINTER:
    myColors.push_back( Color( 0, 0, 255 ));
    myColors.push_back( Color( 0, 255, 132 ));
    break;
  case CMAP_COOL:
    myColors.push_back( Color( 0, 255, 255 ));
    myColors.push_back( Color( 255, 0, 255 ));
    break;
  case CMAP_COPPER:
    myColors.push_back( Color( 0, 0, 0 ));
    myColors.push_back( Color( 255, 198, 123 ));
    break;
  case CMAP_HOT:
    myColors.push_back( Color::Black );
    myColors.push_back( Color::Red );
    myColors.push_back( Color( 255, 140, 0 ) );
    myColors.push_back( Color::Yellow );
    myColors.push_back( Color::White );
    break;
  case CMAP_JET:
    myColors.push_back( Color::Blue );
    myColors.push_back( Color::Cyan );
    myColors.push_back( Color::Yellow );
    myColors.push_back( Color( 255, 140, 0 ) );
    myColors.push_back( Color::Red );
    myColors.push_back( Color( 132, 0, 0 ) );
    break;
  case CMAP_CUSTOM:
    if ( firstColor != Color::None
   && lastColor != Color::None ) {
      myColors.push_back( firstColor );
      myColors.push_back( lastColor );   
    }
    break;
  }
}

template <typename PValue,
    int PDefaultPreset,
    int PDefaultFirstColor,
    int PDefaultLastColor >
inline
DGtal::GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor>::GradientColorMap
( const GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor> & other )
  : myMin( other.myMin ), myMax( other.myMax ), myColors( other.myColors )
{ 
}

template <typename PValue,
    int PDefaultPreset,
    int PDefaultFirstColor,
    int PDefaultLastColor >
inline
DGtal::GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor>::~GradientColorMap()
{
}

template <typename PValue,
    int PDefaultPreset,
    int PDefaultFirstColor,
    int PDefaultLastColor >
GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor> &
GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor>::operator=
( const GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor> & other )
{
  if ( &other != this ) {
    myMin = other.myMin;
    myMax = other.myMax;
    myColors = other.myColors;
  }
  return *this;
}

// Interface - public :


template<typename PValue,
   int PDefaultPreset,
   int PDefaultFirstColor,
   int PDefaultLastColor >
inline
void
DGtal::GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor>::addColor
( const Color & color )
{
  myColors.push_back( color );
}

template<typename PValue,
   int PDefaultPreset,
    int PDefaultFirstColor,
    int PDefaultLastColor >
inline
void
DGtal::GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor>::clearColors()
{
  myColors.clear();
}

template<typename PValue,
   int PDefaultPreset,
    int PDefaultFirstColor,
    int PDefaultLastColor >
inline
const PValue &
DGtal::GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor>::min() const
{
  return myMin;
}

template<typename PValue,
   int PDefaultPreset,
    int PDefaultFirstColor,
    int PDefaultLastColor >
inline
const PValue &
DGtal::GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor>::max() const
{
  return myMax;
}

template<typename PValue,
   int PDefaultPreset,
    int PDefaultFirstColor,
    int PDefaultLastColor >
inline
Color
DGtal::GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor>::operator()
  ( const Value & value ) const
{
  return GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor>::getColor( myColors,
                           myMin,
                           myMax,
                           value );
}

template <typename PValue,
    int PDefaultPreset,
    int PDefaultFirstColor,
    int PDefaultLastColor >
inline
void
DGtal::GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor>::selfDisplay
( std::ostream & out ) const
{
  out << "[GradientColorMap " 
      << " min=" << myMin
      << " max=" << myMax;
  std::vector<Color>::iterator it = myColors.begin();
  while ( it != myColors.end() ) {
    out << " RGB(" 
  << it->red() << ","
  << it->green() << ","  
  << it->blue() << ") ";
    ++it;
  }
  out << " ]";
}

template <typename PValue,
    int PDefaultPreset,
    int PDefaultFirstColor,
    int PDefaultLastColor >
inline
bool
DGtal::GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor>::isValid() const
{
    return true;
}

template <typename PValue,
    int PDefaultPreset,
    int PDefaultFirstColor,
    int PDefaultLastColor >
inline
Color
DGtal::GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor>::getColor
( const std::vector<Color> & colors,
  const Value & min,
  const Value & max,
  const Value & value )
{
  if ( colors.size() < 2 )
    return Color::None;
  double scale = static_cast<double>( value - min ) / (max - min);
  const int intervals = (const int)colors.size() - 1;
  int upper_index = static_cast<int>( ceil( intervals * scale ) );
  if ( !upper_index ) // Special case when value == min.
    upper_index = 1;
  const Color & firstColor = colors[ upper_index - 1 ];
  const Color & lastColor = colors[ upper_index ];
  scale = ( scale * intervals ) - (upper_index - 1);

  const unsigned char red = static_cast<unsigned char>( firstColor.red() +
              scale * ( lastColor.red() - 
                  firstColor.red() ));
  const unsigned char green = static_cast<unsigned char>( firstColor.green() +
                scale * ( lastColor.green() - 
                    firstColor.green() ));
  const unsigned char blue = static_cast<unsigned char>( firstColor.blue() +
               scale * ( lastColor.blue() - 
                   firstColor.blue() ));
  return Color( red, green, blue );
}

// Implementation of inline functions                                        //

template <typename PValue,
    int PDefaultPreset,
    int PDefaultFirstColor,
    int PDefaultLastColor >
inline
std::ostream&
DGtal::operator<< ( std::ostream & out, 
      const GradientColorMap<PValue,PDefaultPreset,PDefaultFirstColor,PDefaultLastColor> & object )
{
  object.selfDisplay( out );
  return out;
}

//                                                                           //


// Interface - private :