HueShadeColorMap.ih

#include <cstdlib>

// IMPLEMENTATION of inline methods.

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


template <typename Value, int DefaultCycles>
inline
DGtal::HueShadeColorMap<Value,DefaultCycles>::HueShadeColorMap
( const Value & amin,
  const Value & amax,
  const unsigned int cycles )
  : myMin( amin ), myMax( amax ), myCycles( cycles )
{ }


template <typename Value, int DefaultCycles>
inline
DGtal::HueShadeColorMap<Value,DefaultCycles>::HueShadeColorMap
( const HueShadeColorMap<Value,DefaultCycles> & other )
  : myMin( other.myMin ), myMax( other.myMax ), myCycles( other.myCycles )
{ 
}

template <typename Value, int DefaultCycles>
inline
DGtal::HueShadeColorMap<Value,DefaultCycles>::~HueShadeColorMap()
{
}

template <typename Value, int DefaultCycles>
HueShadeColorMap<Value,DefaultCycles> &
HueShadeColorMap<Value,DefaultCycles>::operator=
( const HueShadeColorMap<Value,DefaultCycles> & other )
{
  if ( &other != this ) {
    myMin = other.myMin;
    myMax = other.myMax;
    myCycles = other.myCycles;
  }
  return *this;
}

// Interface - public :

template<typename Value, int DefaultCycles>
inline
const Value &
DGtal::HueShadeColorMap<Value,DefaultCycles>::min() const
{
  return myMin;
}

template<typename Value, int DefaultCycles>
inline
const Value &
DGtal::HueShadeColorMap<Value,DefaultCycles>::max() const
{
  return myMax;
}

template<typename Value, int DefaultCycles>
inline
void
DGtal::HueShadeColorMap<Value,DefaultCycles>::setCycles( int cycles )
{
  myCycles = cycles;
}


template<typename Value, int DefaultCycles>
inline
Color
DGtal::HueShadeColorMap<Value,DefaultCycles>::operator()
  ( const Value & value ) const
{
  return getColor( myCycles, myMin, myMax, value );
}

template <typename Value, int DefaultCycles>
inline
void
DGtal::HueShadeColorMap<Value,DefaultCycles>::selfDisplay ( std::ostream & out ) const
{
  out << "[HueShadeColorMap " 
      << " min=" << myMin
      << " max=" << myMax
      << " cycles=" << myCycles
      << " ]";
}

template <typename Value, int DefaultCycles>
inline
bool
DGtal::HueShadeColorMap<Value,DefaultCycles>::isValid() const
{
    return true;
}

template <typename Value, int DefaultCycles>
inline
Color
DGtal::HueShadeColorMap<Value,DefaultCycles>::getColor
( const unsigned int cycles,
  const Value & min,
  const Value & max,
  const Value & value )
{
  const double scale = ( value - min ) / static_cast<double>( max - min );
  const double hue = 360 * ( scale * cycles - floor(scale * cycles));
  double red, green, blue;
  HueShadeColorMap<Value,DefaultCycles>::HSVtoRGB( red, green, blue, hue, 0.9, 1.0 );
  return Color( static_cast<int>( red * 255), 
    static_cast<int>( green * 255),
    static_cast<int>( blue * 255) );
}

// Implementation of inline functions                                        //

template <typename Value, int DefaultCycles>
inline
std::ostream&
DGtal::operator<< ( std::ostream & out, 
      const HueShadeColorMap<Value,DefaultCycles> & object )
{
  object.selfDisplay( out );
  return out;
}

//                                                                           //


// Interface - private :

template <typename Value, int DefaultCycles>
inline
void
DGtal::HueShadeColorMap<Value,DefaultCycles>::HSVtoRGB
( double & r, double & g, double & b,
  const double h, const double s, const double v)
{
  int i;
  double f, p, q, t;
  if( s == 0 ) {                     // achromatic (gray)
    r = g = b = v;
    return;
  }
  i = static_cast<int>( floor( h / 60 ) );
  f = ( h / 60 ) - i;                        // factorial part of h
  p = v * ( 1.0 - s );
  q = v * ( 1.0 - s * f );
  t = v * ( 1.0 - s * ( 1.0 - f ) );
  switch( i ) {
  case 0:
    r = v; g = t; b = p;
    break;
  case 1:
    r = q; g = v; b = p;
    break;
  case 2:
    r = p; g = v; b = t;
    break;
   case 3:
     r = p; g = q; b = v;
     break;
  case 4:
    r = t;  g = p; b = v;
    break;
  default:    // case 5:
    r = v; g = p; b = q;
    break;
  }
}