BinToColorScaleMovingBrkPt.cxx

Go to the documentation of this file.

#include "BinToColorScaleMovingBrkPt.h"

#include <cassert>
#include <cmath>

using std::vector;

BinToColorScaleMovingBrkPt::
BinToColorScaleMovingBrkPt ( const char * name )
  : BinToColor ( name )
{
  m_control_points.push_back(0.5);
  m_control_points.push_back(0.25);
  m_control_points.push_back(0);
 
}

BinToColorScaleMovingBrkPt::
BinToColorScaleMovingBrkPt ( const std::vector < double > & sv, 
                             const std::string & model_name)
  : BinToColor ( model_name )
{
  assert(sv.size()!=0);
  m_control_points.push_back(sv[0]);
  m_control_points.push_back(sv[1]);
  m_control_points.push_back(sv[2]);
}

BinToColorScaleMovingBrkPt::
BinToColorScaleMovingBrkPt ( const BinToColorScaleMovingBrkPt & bin_to_color )
  : BinToColor ( bin_to_color )
{
 
  if(m_control_points.size()==0)
    {
      m_control_points.push_back( 0.5 );
      m_control_points.push_back( 0.25 );
      m_control_points.push_back( 0 );
    }
}

BinToColor * BinToColorScaleMovingBrkPt:: clone () const
{
  return new BinToColorScaleMovingBrkPt ( *this );
}


void
BinToColorScaleMovingBrkPt::
doubleToColor ( double value, Color & color ) const
{

   double r = 1; double g = 1; double b = 1;   
   double dv = m_range.length ();
   double vmin = m_range.low ();
   double v = value;

   assert(m_control_points.size()!=0);
   double brk_pt = m_control_points[0];
   double flat = m_control_points[1];
   double col = m_control_points[2];
   

   if ( brk_pt <= (1 - brk_pt))
     flat = flat * ( brk_pt);
   else flat = flat * ( 1 - brk_pt);

    if ( v < ( vmin + col*dv ) )
      v = v + 1.5 * dv;

    //Red
    if ( v < ( vmin + ( 1.25 * brk_pt - 0.5 * flat  + col) * dv ) ) 
      r = 0;

    else if ( v > ( vmin + ( 1.25 * brk_pt - 0.5 * flat  + col) * dv ) &&
              v < ( vmin + ( 1.25 * brk_pt + 0.5 * flat + col) * dv ) )
      r = ( v - vmin - ( 1.25 * brk_pt - 0.5 * flat + col) * dv ) / 
          ( ( (flat+0.001) ) * dv );

    else if( v > ( vmin + ( 1.25 * brk_pt + 0.5 * flat + col) * dv ) &&  
             v < ( vmin + ( 1.25 + col ) * dv ) ) 
      r = 1;  

    else r = 1 -  4 * ( v - vmin - ( 1.25 + col ) * dv ) / dv;


    //Green
    if ( v < (vmin + (brk_pt - flat + col) * dv ))
      g = (v - vmin - col*dv ) / ( (0.001+brk_pt - flat ) * dv );

    else if ( v > (vmin + (brk_pt - flat + col) * dv ) &&
              v < ( vmin + (brk_pt + flat + col) * dv ) )      
      g = 1;

    else if ( v > ( vmin + (brk_pt + flat + col) * dv ) &&
              v < ( vmin + ( 1 + col ) * dv ) )       

      g =  1 - ( v - vmin - ( brk_pt + flat + col )*dv)/
       ( (1.001 - brk_pt - flat ) * dv );
  
    else  g = 0;
   

    //Blue
    if ( v < (vmin + ( 0.75 * brk_pt -  0.5 * flat + col ) * dv ) ) 
      b = 1;

    else if ( v > (vmin + ( 0.75 * brk_pt -  0.5 * flat + col ) * dv ) &&
              v < (vmin + ( 0.75 * brk_pt  +  0.5 * flat  + col) * dv ) ) 
     
      b = 1 - ( v - vmin - ( 0.75 * brk_pt - 0.5 * flat + col )*dv ) / 
        ( ( (flat + 0.001) ) * dv );
 
    else if ( v > (vmin + ( 0.75 * brk_pt  +  0.5 * flat  + col) * dv ) && 
               v < ( vmin + ( 1 + col ) * dv ) ) 
      b = 0;  

    else if ( v > ( vmin + ( 1 + col ) * dv ) &&  
              v < ( vmin + ( 1.25 + col ) * dv ) )
     
      b = 4 * ( v - vmin - ( 1 + col ) * dv ) / dv ; 

    else b = 1;

   int red   = static_cast < int > ( r * 255. );
   int green = static_cast < int > ( g * 255. );
   int blue  = static_cast < int > ( b * 255. );
   
 
   assert ( red < 256 && green < 256 && blue < 256 );
   color.setColor ( red, green, blue );
}

bool
BinToColorScaleMovingBrkPt::
hasControlPoints () const
{
  return true;
}

---