BinToUsrDefinedScale.cxx

Go to the documentation of this file.
00001 
00012 #include "BinToUsrDefinedScale.h"
00013 
00014 #include <cassert>
00015 
00016 using namespace hippodraw;
00017 
00018 BinToUsrDefinedScale::
00019 BinToUsrDefinedScale ( const char * name )
00020   : BinToColor ( name )
00021 {
00022   m_control_points.push_back(0.5);
00023   m_control_points.push_back(0.25);
00024 }
00025 
00026 BinToUsrDefinedScale::
00027 BinToUsrDefinedScale ( const BinToUsrDefinedScale & bin_to_color )
00028   : BinToColor ( bin_to_color )
00029 {
00030 }
00031 
00032 BinToColor * BinToUsrDefinedScale:: clone () const
00033 {
00034   return new BinToUsrDefinedScale ( *this );
00035 }
00036 
00037 
00040 void
00041 BinToUsrDefinedScale::
00042 doubleToColor ( double value, Color & color ) const
00043 {
00044    double r = 1; double g = 1; double b = 1;   
00045    double v = value;
00046 
00047    assert(m_control_points.size()!=0);
00048    double brk_pt = m_control_points[0];
00049    double flat = m_control_points[1];
00050    double col = m_control_points[2];
00051    
00052 
00053    if ( brk_pt <= (1 - brk_pt))
00054      flat = flat * ( brk_pt);
00055    else flat = flat * ( 1 - brk_pt);
00056 
00057     if ( v < ( m_vmin + col*m_dv ) )
00058       v = v + 1.5 * m_dv;
00059 
00060     //Red
00061     if ( v < ( m_vmin + ( 1.25 * brk_pt - 0.5 * flat  + col) * m_dv ) ) 
00062       r = 0;
00063 
00064     else if ( v > ( m_vmin + ( 1.25 * brk_pt - 0.5 * flat  + col) * m_dv ) &&
00065               v < ( m_vmin + ( 1.25 * brk_pt + 0.5 * flat + col) * m_dv ) )
00066       r = ( v - m_vmin - ( 1.25 * brk_pt - 0.5 * flat + col) * m_dv ) / 
00067           ( ( (flat+0.001) ) * m_dv );
00068 
00069     else if( v > ( m_vmin + ( 1.25 * brk_pt + 0.5 * flat + col) * m_dv ) &&  
00070              v < ( m_vmin + ( 1.25 + col ) * m_dv ) ) 
00071       r = 1;  
00072 
00073     else r = 1 -  4 * ( v - m_vmin - ( 1.25 + col ) * m_dv ) / m_dv;
00074 
00075 
00076     //Green
00077     if ( v < (m_vmin + (brk_pt - flat + col) * m_dv ))
00078       g = (v - m_vmin - col*m_dv ) / ( (0.001+brk_pt - flat ) * m_dv );
00079 
00080     else if ( v > (m_vmin + (brk_pt - flat + col) * m_dv ) &&
00081               v < ( m_vmin + (brk_pt + flat + col) * m_dv ) )      
00082       g = 1;
00083 
00084     else if ( v > ( m_vmin + (brk_pt + flat + col) * m_dv ) &&
00085               v < ( m_vmin + ( 1 + col ) * m_dv ) )       
00086 
00087       g =  1 - ( v - m_vmin - ( brk_pt + flat + col )*m_dv)/
00088        ( (1.001 - brk_pt - flat ) * m_dv );
00089   
00090     else  g = 0;
00091    
00092 
00093     //Blue
00094     if ( v < (m_vmin + ( 0.75 * brk_pt -  0.5 * flat + col ) * m_dv ) ) 
00095       b = 1;
00096 
00097     else if ( v > (m_vmin + ( 0.75 * brk_pt -  0.5 * flat + col ) * m_dv ) &&
00098               v < (m_vmin + ( 0.75 * brk_pt  +  0.5 * flat  + col) * m_dv ) ) 
00099      
00100       b = 1 - ( v - m_vmin - ( 0.75 * brk_pt - 0.5 * flat + col )*m_dv ) / 
00101         ( ( (flat + 0.001) ) * m_dv );
00102  
00103     else if ( v > (m_vmin + ( 0.75 * brk_pt  +  0.5 * flat  + col) * m_dv ) && 
00104                v < ( m_vmin + ( 1 + col ) * m_dv ) ) 
00105       b = 0;  
00106 
00107     else if ( v > ( m_vmin + ( 1 + col ) * m_dv ) &&  
00108               v < ( m_vmin + ( 1.25 + col ) * m_dv ) )
00109      
00110       b = 4 * ( v - m_vmin - ( 1 + col ) * m_dv ) / m_dv ; 
00111 
00112     else b = 1;
00113 
00114    int red   = static_cast < int > ( r * 255. );
00115    int green = static_cast < int > ( g * 255. );
00116    int blue  = static_cast < int > ( b * 255. );
00117    
00118  
00119    assert ( red < 256 && green < 256 && blue < 256 );
00120    color.setColor ( red, green, blue );
00121 //    double r = 1; double g = 1; double b = 1;   
00122 //    double v = value;
00123  
00124 //    assert(m_control_points.size()!=0);
00125 //    double brk_pt = m_control_points[0];
00126 //    double flat = m_control_points[1];
00127  
00128 //    if ( brk_pt <= (1 - brk_pt))
00129 //      flat = flat * ( brk_pt);
00130 //    else flat = flat * ( 1 - brk_pt);
00131 
00132 
00133 
00134 //    if ( v < ( m_vmin + ( 1.25 * brk_pt - 0.5 * flat ) * m_dv ) ) 
00135 //       r = 0;
00136 
00137 //    else if( v > ( m_vmin + ( 1.25 * brk_pt + 0.5 * flat ) * m_dv ) ) 
00138 //       r = 1;  
00139 
00140 //    else r = ( v - m_vmin - ( 1.25 * brk_pt - 0.5 * flat ) * m_dv ) / 
00141 //        ( ( (flat+0.001) ) * m_dv );
00142 
00143  
00144 
00145 
00146 //    if ( v < (m_vmin + (brk_pt - flat) * m_dv ))
00147 //       g = (v - m_vmin) / ( (0.001+brk_pt - flat) * m_dv );
00148 
00149 //    else if ( v > ( m_vmin + (brk_pt + flat) * m_dv ))      
00150 
00151 //      g =  1 - ( v - m_vmin - ( brk_pt + flat )*m_dv)/
00152 //        ( (1.001 - brk_pt - flat) * m_dv );
00153    
00154 //    else g = 1;
00155 
00156 
00157 
00158 
00159 //    if ( v < (m_vmin + ( 0.75 * brk_pt -  0.5 * flat ) * m_dv ) ) 
00160 //       b = 1;
00161 
00162 //    else if( v > (m_vmin + ( 0.75 * brk_pt  +  0.5 * flat ) * m_dv ) ) 
00163 //       b = 0;  
00164 
00165 //    else b = 1 - ( v - m_vmin - ( 0.75 * brk_pt - 0.5 * flat)*m_dv ) / 
00166 //        ( ( (flat + 0.001) ) * m_dv );
00167 
00168  
00169 
00170 
00171 //    int red   = static_cast < int > ( r * 255. );
00172 //    int green = static_cast < int > ( g * 255. );
00173 //    int blue  = static_cast < int > ( b * 255. );
00174    
00175 
00176 //    assert ( red < 256 && green < 256 && blue < 256 );
00177 //    color.setColor ( red, green, blue );
00178 }
00179 
00180 bool
00181 BinToUsrDefinedScale::
00182 hasControlPoints () const
00183 {
00184   return true;
00185 }
00186 
00187 bool
00188 BinToUsrDefinedScale::
00189 isUserDefined () const
00190 {
00191   return true;
00192 }

Generated for HippoDraw Class Library by doxygen