AxisRepColor.cxx

Go to the documentation of this file.

#ifdef _MSC_VER
// for min()
#include "msdevstudio/MSconfig.h"
#endif

#include "AxisRepColor.h"

#include "BinToColorScale.h"

#include "axes/AxisModelBase.h"
#include "axes/AxisTick.h"
#include "graphics/Color.h"
#include "graphics/ViewBase.h"
#include "transforms/BinaryTransform.h"

#include <algorithm>
#include <functional>

#include <cmath>

#include <cassert>

using std::min;
using std::string;
using std::vector;

using namespace hippodraw;

AxisRepColor::AxisRepColor ()
  : AxisRepBase (),
    m_axis_z_origin( 0.0 ),
    m_axis_depth( 0.0 )
{
}

AxisRepColor::AxisRepColor( const AxisRepColor & axis_rep )
  : AxisRepBase( axis_rep ),
    m_axis_z_origin( axis_rep.m_axis_z_origin ),
    m_axis_depth( axis_rep.m_axis_depth )
{
}

AxisRepBase * AxisRepColor::clone()
{
  return new AxisRepColor( *this );
}


inline float XPADDING( ViewBase & view )
{
  return ( view.getDrawRect().getWidth() * 0.01 );
}

inline float YPADDING( ViewBase & view )
{
  return ( view.getDrawRect().getHeight() * 0.01 );
}

inline float ZPADDING( ViewBase & view )
{
  return ( view.getDrawRect().getWidth() * 0.01 );
}

void AxisRepColor::endPlot()
{
}

void
AxisRepColor::
drawZLabels ( const AxisModelBase & axisModel,
              ViewBase & view, 
              const std::string & z_label )
{
  float x, y;

  HippoRectangle draw_rect = view.getDrawRect ();
  float dh = draw_rect.getHeight ();

  HippoRectangle margin_rect = view.getMarginRect ();
  float mx = margin_rect.getX ();
  float mw = margin_rect.getWidth ();
  float mh = margin_rect.getHeight ();

  float y_font_size = ( dh - mh ) / 2 * 0.20;
  float x_font_size = ( mw * 2 ) / z_label.size() * 2 / 3;

  m_z_font_size = min ( x_font_size, y_font_size );

  x = mx + 0.5 * mw;
  y = YPADDING( view ) + ( dh - mh ) / 2 * 0.30 + YPADDING ( view ) 
    + m_z_font_size ;

  if ( m_zLabelFont != 0 ) {
    view.drawText ( z_label, x, y, 0.0, 0.0, 'c', 'b',
                    false, m_zLabelFont );
  } else {
    view.drawText ( z_label, x, y, m_z_font_size, 0.0, 'c', 'b', false );
  }
}

void AxisRepColor::drawAllZTicks ( const AxisModelBase & axisModel,
                                   const TransformBase & transform,
                                   ViewBase & view )
{
  drawZTickLines ( axisModel, transform, view );
  drawZTickLabels ( axisModel, transform, view );
}

void AxisRepColor::drawZTickLines ( const AxisModelBase & axisModel,
                                    const TransformBase & transform,
                                    ViewBase & view )
{
  AxisLoc loc = axisModel.getLabelLocation ();
  assert ( loc == PLOTBOTTOM || PLOTTOP );

  const vector< AxisTick > & ticks = axisModel.getTicks ();
  if ( ticks.empty() ) return;  

  vector< double > xv;
  vector< double > yv;
  
  unsigned int size = 2 * ticks.size ();
  xv.reserve ( size );
  yv.reserve ( size );

  const BinaryTransform & t 
    = dynamic_cast< const BinaryTransform & > ( transform );
  
  const HippoRectangle view_rect = view.getMarginRect ();
  double tick_length = 0.05 * view_rect.getHeight ();

  double y_base = view_rect.getY() -
    ( 1.0 / 9.0 ) * view_rect.getHeight() - tick_length;

  for ( unsigned int i = 0; i < ticks.size(); i++ ) {
    
    double user_z = ticks[i].value ();
    t.transformZ ( user_z );
    // Reinstate the following line when XYZ transform exists.
    //t.transform ( user_z, y ); // Some valid value on Y.
  
    double view_x = view.userToDrawColor ( user_z );

    xv.push_back ( view_x );
    yv.push_back ( y_base );
    xv.push_back ( view_x );
    yv.push_back ( y_base + tick_length );
  
  }

  view.drawViewLines ( xv, yv, Line::Solid, false, 0 );  

}

void AxisRepColor::drawZTickLabels ( const AxisModelBase & axisModel,
                                     const TransformBase & transform, 
                                     ViewBase & view )
{
  vector < double > xv;  
  vector < double > yv;  
  
  const vector< AxisTick > & ticks = axisModel.getTicks ();
  unsigned int size = ticks.size ();
  if ( size == 0 ) return;

  xv.reserve ( size );
  yv.reserve ( size );

  const BinaryTransform & t 
    = dynamic_cast< const BinaryTransform & > ( transform );

  unsigned int i = 0; // For MS VC++.
  for ( ; i < size; i++ ) {
    double value = ticks[i].value ();
    t.transformZ ( value );
    xv.push_back ( value );
    yv.push_back ( 1.0 ); // Use a valid Y value.
  }

  // Calculate the Y position in view coordinates.
  
  const HippoRectangle & margin = view.getMarginRect ();
  double tick_length = 0.05 * margin.getHeight ();
  float y = margin.getY() - ( 1.0 / 9.0 ) * margin.getHeight() -
    2 * tick_length;
  char yalign = 't';

  i = 0;  // For MS VC++.
  for ( ; i < size; i++ ) {
    float x = view.userToDrawColor ( xv[i] );
    view.drawText( ticks[i].content(), x, y, m_font_size, 0.0, 'c', yalign );
  }       
  
  if ( axisModel.needPMag () ) {
    double pmag = axisModel.getPMag ();
    const HippoRectangle view_rect = view.getDrawRect ();

    float last_x = view.userToDrawColor ( xv[ size -1 ] );
    float x = margin.getX () + last_x;
    
    const AxisTick & last_tick = ticks.back ();
    const string & last_label = last_tick.content ();
    float label_size = last_label.size ();
    x += 0.5 * label_size * m_font_size;
    
    float margin_right = margin.getX () + margin.getWidth ();
    x = min ( x, margin_right + XPADDING ( view ) );
    
    if ( yalign == 't' ) {
      y -= m_font_size * 0.8; // used to be +0.8
    } else {
      y -= m_font_size * 1.8; // might need adjustment?
    }

    x += view_rect.getX();
    y += view_rect.getY();    

    // Logarithmic graphs do not need the magnitude written.
    if(!(axisModel.isLog()))
      view.drawMag ( x, y, static_cast< int >( pmag ), m_font_size * 0.75 );
  }

}

void
AxisRepColor::
drawColorScale ( const BinToColor & bin_to_color, ViewBase & view )
{
  HippoRectangle margin = view.getMarginRect(); 

  double y_base = margin.getY() -
    ( 1.05 / 9.0 ) * margin.getHeight();

  const Range & range = bin_to_color.getRange ();
  double value = range.low ();
  double delta_v = range.length () / margin.getWidth ();
  for ( float i = 0; i <= margin.getWidth() ; i++ ) {
    
    Color color;
    bin_to_color.doubleToColor ( value, color );
    view.drawViewSquare ( margin.getX() + i,
                          y_base,
                          margin.getX() + i + 1.0,
                          y_base + 0.05 * margin.getHeight(),
                          color.getRed(),
                          color.getGreen(),
                          color.getBlue () );
    value  += delta_v;
  }
  
  view.drawViewSquare( margin.getX(),
                     y_base,
                     margin.getX(),
                     y_base + 0.05 * margin.getHeight(),
                     0, 0, 0 );
}

---