AxisRepBase.cxx

Go to the documentation of this file.

// for tex
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

// for truncation warning
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#define finite _finite
#endif

#include "AxisRepBase.h"

#include "axes/AxisModelBase.h"
#include "graphics/Color.h"
#include "graphics/DataView.h"
#include "pattern/string_convert.h"
#include "transforms/PeriodicBinaryTransform.h"

#include <cmath>
#include <cassert>

using std::max;
using std::min;
using std::string;
using std::vector;
#ifdef __USE_ISOC99
using std::isfinite;
#endif

using namespace hippodraw;

AxisRepBase::AxisRepBase()
  : m_sci_note_x(false), 
    m_sci_note_y(false),
    m_axis_x_origin (0.),
    m_axis_y_origin ( 0.0),
    m_axis_width ( 0.0 ),
    m_axis_height ( 0.0 ),
    m_font_size( 1.0 ), 
    m_x_tick_font_size ( 1.0 ),
    m_y_tick_font_size ( 1.0 ),
    m_x_font_size( 1.0 ), 
    m_y_font_size( 1.0 ),
    m_xLabelFont( 0 ),
    m_yLabelFont( 0 ),
    m_zLabelFont( 0 ),
    m_titleFont( 0 ),
    m_draw_titles( true )
{
}

AxisRepBase::AxisRepBase( const AxisRepBase & axis_rep )
  : m_sci_note_x(axis_rep.m_sci_note_x),
    m_sci_note_y(axis_rep.m_sci_note_y),
    m_axis_x_origin( axis_rep.m_axis_x_origin ),
    m_axis_y_origin( axis_rep.m_axis_y_origin ),
    m_axis_width( axis_rep.m_axis_width ),
    m_axis_height( axis_rep.m_axis_height ),
    m_font_size( axis_rep.m_font_size ),
    m_x_font_size( axis_rep.m_x_font_size ),
    m_y_font_size( axis_rep.m_y_font_size ),
    m_xLabelFont( axis_rep.m_xLabelFont ),
    m_yLabelFont( axis_rep.m_yLabelFont ),
    m_zLabelFont( axis_rep.m_zLabelFont ),
    m_titleFont( axis_rep.m_titleFont ),
    m_draw_titles( axis_rep.m_draw_titles )
{
}

AxisRepBase::~AxisRepBase()
{
  delete m_xLabelFont;
  delete m_yLabelFont;
  delete m_zLabelFont;
  delete m_titleFont;
}

void
AxisRepBase::
initAxisRect( ViewBase & view )
{
  const Rect & rect = view.getUserRect();

  m_axis_x_origin = rect.getX();
  m_axis_y_origin = rect.getY();
  m_axis_width = rect.getWidth();
  m_axis_height = rect.getHeight();
}

void
AxisRepBase::
beginPlot( ViewBase & view )
{
  initAxisRect( view );
}

void AxisRepBase::setDrawTitles( bool set )
{
  m_draw_titles = set;
}

void
AxisRepBase::
drawTitle ( ViewBase & base, const std::string & title )
{

  DataView & view = dynamic_cast < DataView & > ( base );

  // Draw Latex at the top of the plotter if in Latex format
#ifdef HAVE_TEX_UTILS
  if (String::ci_find(title, "tex:")==0) {
    string tex_snippet = title.substr(4);
    view.drawLatex ( tex_snippet, 1 );
  }

  else {
#endif
    const Rect & marginRect = view.getMarginRect();
    float mx = marginRect.getX();
    Rect rect = view.getDrawRect ();
    float mw = rect.getWidth();
    
    double x_font_size = ( 1.3 * mw ) / title.size();
    m_font_size = min(x_font_size,12.0);
    
    double one = 1.0;
    m_font_size = max ( m_font_size, one );
    
    float x = mx + 0.5 * marginRect.getWidth ();
    float y = 2.0;
    
    if ( m_titleFont != 0 ) {
      view.drawText ( title, x, y, 0.0, 0.0, 'c', 't', false,
                      m_titleFont );
    } else {
      view.drawText ( title, x, y, m_font_size, 0.0, 'c', 't', false );
    }

#ifdef HAVE_TEX_UTILS
  }
#endif
}

void
AxisRepBase::
setXFontSize ( const AxisModelBase & axisModel,
               ViewBase & view )
{
  Rect draw_rect = view.getDrawRect();
  m_x_tick_font_size = min( ( draw_rect.getWidth() ) * 0.040, 12.0 );
  double one = 1.0;
  m_x_tick_font_size = max ( m_x_tick_font_size, one );

  AxisLoc location = axisModel.getScaleLocation();
  
  if ( location == PLOTBOTTOM )
    {
      m_x_font_size = min( (double)m_x_tick_font_size,
                           ( m_axis_y_origin -
                             draw_rect.getY() ) / 2.0 );
    }
  else if ( location == PLOTTOP )
    {
      m_x_font_size = min( (double)m_x_tick_font_size,
                           ( draw_rect.getHeight() -
                             m_axis_height -
                             ( m_axis_y_origin
                               - draw_rect.getY() ) ) /2.0 );
    }
}

void
AxisRepBase::
setYFontSize ( const AxisModelBase & axisModel,
               ViewBase & view )
{
  assert ( m_y_tick_font_size > 0 );

  Rect draw_rect = view.getDrawRect();
  double height = draw_rect.getHeight ();
  double size = height * 0.040;
  size = std::min ( size, 11.0 );
  double one = 1.0;
  m_y_tick_font_size = std::max ( size, one );
  
  assert ( m_y_tick_font_size > 0 );
  const vector<AxisTick> & labels = axisModel.getTicks ( );
  if ( labels.empty () == true ) return;

  if ( axisModel.getScaleLocation() & PLOTLEFT )
    {
      float yr;
      
      if ( m_draw_titles && 
           axisModel.getLabelLocation() & PLOTLEFT ) {
        yr = 14;
      } 
      else {
        yr = 0;
      }
      const AxisTick & tick = labels.back ( );
      m_y_font_size = min ( m_y_tick_font_size, 
                           ( m_axis_x_origin -
                             draw_rect.getX() - yr )
                           / tick.content().size() );
    }
  else if ( axisModel.getScaleLocation() & PLOTRIGHT )
    {
      // Estimates the space needed for the Y axis label.
      float yr;
      if ( m_draw_titles && 
           axisModel.getLabelLocation() & PLOTRIGHT ) {
        yr = 14;
      } else {
        yr = 0;
      }

      m_y_font_size = min( m_y_tick_font_size, 
                   ( draw_rect.getWidth() - 
                     m_axis_width - 
                     ( m_axis_x_origin - 
                       draw_rect.getX() ) - yr )
                   / labels[labels.size() - 1].content().size() );
    }
}

void
AxisRepBase::
setZFontSize ( const AxisModelBase & axisModel,
               ViewBase & view )
{
  AxisLoc location = axisModel.getScaleLocation();
  Rect draw_rect = view.getDrawRect();
  if ( location == PLOTBOTTOM )
    {
      m_z_font_size = min( (double)m_font_size,
                           ( m_axis_y_origin -
                             draw_rect.getY() ) / 2.0 );
    }
  else if ( location == PLOTTOP )
    {
      m_z_font_size = min( (double)m_font_size,
                           ( draw_rect.getHeight() -
                             m_axis_height -
                             ( m_axis_y_origin
                               - draw_rect.getY() ) ) /2.0 );
    }
}

void
AxisRepBase::
drawXLabels ( const AxisModelBase & axisModel,
              ViewBase & base, const std::string & x_label )
{
  DataView & view = dynamic_cast < DataView & > ( base );

  // Calculate the ratio of range(rmag) and value(pmag) to decide
  // where scientific notation is needed.
  const vector< AxisTick > & ticks = axisModel.getTicks();
  m_sci_note_x=false;
  int mid = ticks.size()/2;
  double ref = ticks[mid].value();
  double range = ticks[mid+1].value()-ref;
  if (fabs(ref/range)>1e6) m_sci_note_x=true;
  
  // Draw Latex at the bottom of the plotter if in Latex format
#ifdef HAVE_TEX_UTILS
  if (String::ci_find(x_label, "tex:")==0) {
    string tex_snippet = x_label.substr(4);
    if (m_sci_note_x) {
      tex_snippet+="-"+ticks[mid].content();
      if (axisModel.needPMag()) {
        // Use LaTeX to generate: label-mid*10^Pmag
        tex_snippet+="\\times 10^"+String::convert ( static_cast <int> (axisModel.getPMag()) );
      }
    }
    view.drawLatex ( tex_snippet, 2 );
  }

  else {    
#endif
    std::string label;
    if (m_sci_note_x) {
      label = x_label+" - "+ticks[mid].content();
    }
    else {
      label = x_label;
    }
    
    float x = 0., y = 0.;
    Rect draw_rect = view.getDrawRect ();
    float draw_h = draw_rect.getHeight ();
    float draw_w = draw_rect.getWidth ();
    
    const Rect & margin_rect = view.getMarginRect ();
    float margin_x = margin_rect.getX ();
    float margin_w = margin_rect.getWidth ();
    
    x = margin_x + 0.5 * margin_w;
    
    float tmp = 0.045 * draw_w;
    tmp = max ( tmp, 1.0f );
    m_x_font_size = min ( tmp, static_cast<float>( 18.0 ) );
    assert ( m_x_font_size > 0 );    
    
    double ratio = draw_w / ( label.size() ) * 2;
    m_x_font_size = std::min ( m_x_font_size, ratio );
    assert ( m_x_font_size > 0 );    
    double one = 2.0;
    m_x_font_size = std::max ( m_x_font_size, one );

    assert ( m_x_font_size > 0 );    
    if ( axisModel.getLabelLocation() & PLOTBOTTOM )
      {
        if ( m_xLabelFont != 0 ) {
          y = draw_h - 1.5*m_xLabelFont->pointSize()-6.0; // experimental
          view.drawText ( label, x, y, 0., 0.0, 'c', 't',
                          false, m_xLabelFont );
        } else {
          y = draw_h - m_x_font_size - 6.0; // take into account descenders
          view.drawText ( label, x, y, m_x_font_size, 0.0, 'c', 't', false );
        }
      }
    else if ( axisModel.getLabelLocation() & PLOTTOP )
      {
        y = 1.0;
        if ( m_xLabelFont != 0 ) {
          
          view.drawText ( label, x, y, 0.0, 0.0, 'c', 't',
                          false, m_xLabelFont );
        } else {
          
          view.drawText ( label, x, y, m_x_font_size, 0.0, 'c', 't', false );
        }
      }
    
    
    // Draw the mag when both pmag and small range sci_note are needed.
    // TODO: handle (location & PLOTTOP)
    if ( (m_sci_note_x) && (axisModel.needPMag() ) ){
      if ( m_xLabelFont == NULL ) {
        x = x+0.27 * m_x_font_size * label.size();
        y = y+0.2 * m_x_font_size;
        view.drawText ( " x10", x, y, m_x_font_size*0.8, 0.0, 'c', 't', false );
        
        double pmag = axisModel.getPMag();
        int i = static_cast < int > ( pmag );
        const string text = String::convert ( i );
        x += 1.0 * m_x_font_size ;
        y -= 0.4 * m_x_font_size;  
        view.drawText ( text, x, y, m_x_font_size*0.8, 0.0, 'c', 't', false );
      } else {
        x = x+0.4 * m_xLabelFont->pointSize() * label.size();
        view.drawText ( " x10", x, y, 0.0, 0.0, 'c', 't', false, m_xLabelFont );
        
        double pmag = axisModel.getPMag();
        int i = static_cast < int > ( pmag );
        const string text = String::convert ( i );
        x += 1.6 * m_xLabelFont->pointSize() ;
        y -= 0.4 * m_xLabelFont->pointSize();
        view.drawText ( text, x, y, 0.0, 0.0, 'c', 't', false, m_xLabelFont );
      }
    }
#ifdef HAVE_TEX_UTILS
  }
#endif
  
}
void
AxisRepBase::
drawYLabels ( const AxisModelBase & axisModel,
              ViewBase & base, const std::string & y_label )
{
  DataView & view = dynamic_cast < DataView & > ( base );

  // Calculate the ratio of range(rmag) and value(pmag) to decide
  // where scientific notation is needed.
  const vector< AxisTick > & ticks = axisModel.getTicks();
  m_sci_note_y=false;
  int mid = ticks.size()/2;
  double ref = ticks[mid].value();
  double range = ticks[mid+1].value()-ref;
  if (fabs(ref/range)>1e6) m_sci_note_y=true;
  
  
#ifdef HAVE_TEX_UTILS
  // Draw Latex at the left of the plotter if in Latex format
  if (String::ci_find(y_label, "tex:")==0) {
    string tex_snippet = y_label.substr(4);
   
    if (m_sci_note_y) {
      tex_snippet+="-"+ticks[mid].content();
      if (axisModel.needPMag()) {
        // Use LaTeX to generate: label-mid*10^Pmag
        tex_snippet+="\\times 10^"+String::convert ( static_cast <int> (axisModel.getPMag()) );
      }
    }


    view.drawLatex ( tex_snippet, 3 );
  }

  else {
#endif

    
    std::string label;
    if (m_sci_note_y) {
      label = y_label+" - "+ticks[mid].content();
    }
    else {
      label = y_label;
    }
    
    Rect draw_rect = view.getDrawRect ();

    float x = 0., y = 0.;
    AxisLoc location = axisModel.getLabelLocation();
    
    //float tmp = min ( view.getDrawRect().getWidth() * 0.05,
    //      view.getDrawRect().getHeight() * 0.05 );
    float tmp = draw_rect.getHeight() * 0.05;
    m_y_font_size = min( tmp, static_cast<float>( 18.0 ) );
    m_y_font_size = min( m_y_font_size, draw_rect.getHeight()
                         / ( label.size() ) * 2 );
    double one = 1.0;
    m_y_font_size = max ( m_y_font_size, one );
    y = view.getMarginRect().getY() + 
      view.getMarginRect().getHeight() *0.5;
    
    if ( location & PLOTLEFT )
      {
        x = 2.0;
        if ( m_yLabelFont != 0 ) {
          view.drawText ( label, x, y, 0.0, 90.0, 'c', 't',
                          false, m_yLabelFont );
        } else {
          view.drawText ( label, x, y, m_y_font_size, 90.0, 'c', 't', false );
        }
      }
    else if ( location & PLOTRIGHT )
      {
        x = draw_rect.getWidth() - 2.0;
        if ( m_yLabelFont != 0 ) {
          view.drawText ( label, x, y, 0.0, -90.0, 'c', 't',
                          false, m_yLabelFont );
        } else {
          view.drawText ( label, x, y, m_y_font_size, -90.0, 'c', 't', false );
        }
      }
    
    
    // Draw the mag when both pmag and small range sci_note are needed.
    // TODO: handle (location & PLOTTOP)
    if ( (m_sci_note_y) && (axisModel.needPMag() ) ){
      if ( m_yLabelFont == NULL ) {
        y = y-0.27 * m_y_font_size * label.size();
        x = x+0.2 * m_y_font_size;
        view.drawText ( " x10", x, y, m_y_font_size*0.8, 90.0, 'c', 't', false );
        
        double pmag = axisModel.getPMag();
        int i = static_cast < int > ( pmag );
        const string text = String::convert ( i );
        x -= 0.4 * m_y_font_size ;
        y -= 1.0 * m_y_font_size;  
        view.drawText ( text, x, y, m_y_font_size*0.8, 90.0, 'c', 't', false );
      } else {
        y = y-0.4 * m_yLabelFont->pointSize() * label.size();
        view.drawText ( " x10", x, y, 0.0, 90.0, 'c', 't', false, m_yLabelFont );
        
        double pmag = axisModel.getPMag();
        int i = static_cast < int > ( pmag );
        const string text = String::convert ( i );
        x -= 0.4 * m_yLabelFont->pointSize() ;
        y -= 1.6 * m_yLabelFont->pointSize();
        view.drawText ( text, x, y, 0.0, 90.0, 'c', 't', false, m_yLabelFont );
      }
    }
#ifdef HAVE_TEX_UTILS
  }
#endif
}

void
AxisRepBase::
drawReferencePoint( const AxisModelBase & axisModel, 
                    ViewBase & base,
                    const std::string & ref)
{
  if ( axisModel.getScaleLocation() & PLOTBOTTOM )
    {
      DataView & view = dynamic_cast < DataView & > ( base );
      
      const Rect & margin_rect = view.getMarginRect ();
      float x = margin_rect.getX() + margin_rect.getWidth ();
      
      x -= 1 * m_x_tick_font_size * ref.size();
      
      Rect view_rect = view.getDrawRect ();
      float y = + view_rect.getHeight ();
      
      view.drawText ( "X Ref:"+ref, x, y, m_x_tick_font_size, 0., 'l', 'b' );
    }
  else if (axisModel.getScaleLocation() & PLOTLEFT)
    {
      DataView & view = dynamic_cast < DataView & > ( base );

      float x = 2.;
      x += m_y_tick_font_size;
      
      const Rect & margin_rect = view.getMarginRect ();
      float y = margin_rect.getY() + 0.2 * m_y_tick_font_size;
      
      view.drawText ( "Y Ref:"+ref, x, y, m_y_tick_font_size, 0., 'l', 'b' );
    }
      
}


void
AxisRepBase::
drawXMag ( const AxisModelBase & axisModel,
           ViewBase & base , const std::string & mag )
{
  DataView & view = dynamic_cast < DataView & > ( base );

  const Rect & margin_rect = view.getMarginRect ();
  float x = margin_rect.getX() + margin_rect.getWidth ();

  double pmag = axisModel.getPMag();
  int i = static_cast<int> (pmag);
  const string text = String::convert ( i );
  x -= 0.8 * m_x_tick_font_size * text.size();

  Rect view_rect = view.getDrawRect ();
  float y = + view_rect.getHeight ();

  view.drawText ( "x10", x, y, 0.75 * m_x_tick_font_size, 0., 'l', 'b' );

  x += 1.25 * m_x_tick_font_size ;
  y -= 0.5 * m_x_tick_font_size;

  if (m_sci_note_x) {
    view.drawText( mag, x, y, 0.75 * m_x_tick_font_size, 0., 'l', 'b' );
  } else {
    view.drawText ( text, x, y, 0.75 * m_x_tick_font_size, 0., 'l', 'b' );
  }
}

void
AxisRepBase::
drawYMag ( const AxisModelBase & axisModel,
           ViewBase & base, const std::string & mag )
{
  DataView & view = dynamic_cast < DataView & > ( base );

  float x = 2.;
  if ( axisModel.getScaleLocation() & PLOTLEFT ) {
    x += m_y_tick_font_size;
  }
  else {
    x -= m_y_tick_font_size;
  }

  const Rect & margin_rect = view.getMarginRect ();
  float y = margin_rect.getY() + 0.5 * m_y_tick_font_size;

  view.drawText ( "x10", x, y, m_y_tick_font_size, 0., 'l', 'b' );

  double pmag = axisModel.getPMag();
  int i = static_cast < int > ( pmag );
  const string text = String::convert ( i );
  x += 1.75 * m_y_tick_font_size ;
  y -= 0.5 * m_y_tick_font_size;

  if (m_sci_note_y) {
    view.drawText ( mag, x, y, m_y_tick_font_size, 0., 'l', 'b' );
  } else {
    view.drawText ( text, x, y, m_y_tick_font_size, 0., 'l', 'b' );
  }

}

void
AxisRepBase::
drawAxesLines ( TransformBase & transform, 
                ViewBase & view, 
                const Range & x_range,
                const Range & y_range)
{
  const BinaryTransform & t
    = dynamic_cast< const BinaryTransform & > ( transform );
  vector< double > xv ( 100 );
  vector< double > yv ( 100 );
  Color black ( 0, 0, 0 );

  xv[0] = x_range.low( );
  yv[0] = y_range.low( );
  for( int i = 1; i < 100; i++)
    {
      xv[i] = xv[i-1] + ( x_range.high() - x_range.low() )/99; 
      yv[i] = yv[i-1];
    }
  t.transform( xv, yv );
  view.drawPolyLine ( xv, yv, Line::Solid, black, 1 );

  
  xv[0] = x_range.high( );
  yv[0] = y_range.low( );
  for( int i = 1; i < 100; i++)
    {
      xv[i] = xv[i-1]; 
      yv[i] = yv[i-1] + ( y_range.high() - y_range.low() )/99; ;
    }
  t.transform( xv, yv );
  view.drawPolyLine ( xv, yv, Line::Solid, black, 1 );


  xv[0] = x_range.low( );
  yv[0] = y_range.high( );
  for( int i = 1; i < 100; i++)
    {
      xv[i] = xv[i-1] + ( x_range.high() - x_range.low() )/99;  
      yv[i] = yv[i-1];
    }
  
  t.transform( xv, yv );
  view.drawPolyLine ( xv, yv, Line::Solid, black, 1 );


  xv[0] = x_range.low( );
  yv[0] = y_range.low( );
  for( int i = 1; i < 100; i++)
    {
      xv[i] = xv[i-1];
      yv[i] = yv[i-1]  + ( y_range.high() - y_range.low() )/99;  
    }
  
  t.transform( xv, yv );
  view.drawPolyLine ( xv, yv, Line::Solid, black, 1 );

  
}



void AxisRepBase::drawGridLines( const AxisModelBase & axisModelX,
                                 const AxisModelBase & axisModelY,
                                 TransformBase & transform,
                                 ViewBase & view )
{
  Range x_range = axisModelX.getRange( false );
  Range y_range = axisModelY.getRange( false );
  
    
  const vector< AxisTick > & x_ticks = axisModelX.getTicks();
  const vector< AxisTick > & y_ticks = axisModelY.getTicks();
  
  unsigned int nxpoints = 100;
  unsigned int nypoints = 100;
  vector< double > xv(100), yv(100);
  
  double user_x, user_y;
  Color grey( 180, 180, 180 );
    
  BinaryTransform & t
    = dynamic_cast< BinaryTransform & > ( transform );

  t.validate( x_range, y_range );

  if ( x_ticks.empty () == true || y_ticks.empty () == true ) 
    return;

  
  double dx = ( x_range.high() - x_range.low() ) / ( nxpoints - 1 );
  double dy = ( y_range.high() - y_range.low() ) / ( nypoints - 1 ) ;
  
    
  // Drawing the   coordinates of the aligned along y-Axis 
  // i.e.curves for which  x = const
  // Don't draw first tick if it will cover the left edge.
  for ( unsigned int i = ( x_range.low() == x_ticks[0].value() )?1:0; 
        i < x_ticks.size(); i++ )
    {
      user_x = x_ticks[ i ].value();
      
      for ( unsigned int j = 0; j < nypoints; j++ )
        {
          user_y = y_range.low() + j * dy;
                  
          xv[ j ] = user_x;
          yv[ j ] = user_y;
          
        }
      
      t.transform( xv, yv );
      view.drawPolyLine ( xv, yv, Line::Dot, grey, 0 );
      
    }
  
  
  // Drawing the   coordinates of the aligned along x-Axis 
  // i.e.curves for which  y = const
  // Don't draw first tick if it will cover the bottom edge.
  for ( unsigned int j = ( y_range.low() == y_ticks[0].value() )?1:0; 
        j < y_ticks.size(); j++ )
    {
      user_y = y_ticks[ j ].value();
      
      for ( unsigned int i = 0; i < nxpoints; i++ )
        {
          user_x = x_range.low() + i * dx;
        
          xv[ i ] = user_x ;
          yv[ i ] = user_y ;
        }

      t.transform( xv, yv ); 
      view.drawPolyLine( xv, yv, Line::Dot, grey, 0 );
    }
   
   return;
}

void
AxisRepBase::
drawXTickLines( const AxisModelBase & axisModelX,
                const AxisModelBase & axisModelY,
                const TransformBase & transform,
                ViewBase & base )
{
  DataView & view = dynamic_cast < DataView & > ( base );
  AxisLoc loc = axisModelX.getLabelLocation();
  assert( loc == PLOTBOTTOM || PLOTTOP );
  
  const vector< AxisTick > & ticks = axisModelX.getTicks();
  if ( ticks.empty() == true ) return;
  
  vector< double > xv;
  vector< double > yv;

  unsigned int size = 4 * ticks.size();
  xv.reserve( size );
  yv.reserve( size );

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

  const Rect & view_rect = view.getMarginRect();
  double tick_length = 0.05 * view_rect.getHeight();
  tick_length = min ( tick_length, 8. );  
  Range yrange = axisModelY.getRange( false );
  
  for ( unsigned int i = 0; i < ticks.size(); i++ )
    {
      double user_x_start = ticks[i].value ();
      double user_x_temp = user_x_start;

      double user_by_start = yrange.low();
      double user_ty_start = yrange.high();
      
      // transform will change the x value, so we need the temp
      t.transform ( user_x_start, user_by_start );
      t.transform ( user_x_temp, user_ty_start );
      
      double view_x_start = view.userToDrawXAutoInv ( user_x_start );
      double view_by_start = view.userToDrawY ( user_by_start );
      double view_ty_start = view.userToDrawY ( user_ty_start );
      
      double view_x_end = view_x_start;
      double view_by_end = view_by_start - tick_length;
      double view_ty_end = view_ty_start + tick_length;

#ifdef __USE_ISOC99
      if( isfinite( view_x_start ) &&
          isfinite( view_by_start ) &&
          isfinite( view_ty_start ) &&
          isfinite( view_x_start ) &&
          isfinite( view_by_end   ) )
#else
      if( finite( view_x_start ) &&
          finite( view_by_start ) &&
          finite( view_ty_start ) &&
          finite( view_x_start ) &&
          finite( view_by_end   ) )
#endif
        {
          xv.push_back( view_x_start );
          yv.push_back( view_by_start );
          xv.push_back( view_x_end );
          yv.push_back( view_by_end );

          xv.push_back( view_x_start );
          yv.push_back( view_ty_start );
          xv.push_back( view_x_end );
          yv.push_back( view_ty_end );
        }
    }
  
  view.drawViewLines ( xv, yv, Line::Solid, false, 1 );
}

void 
AxisRepBase::
drawYTickLines ( const AxisModelBase & axisModelX,
                 const AxisModelBase & axisModelY,
                 const TransformBase & transform,
                 ViewBase & base )
{
  AxisLoc loc = axisModelY.getLabelLocation ();
  assert ( loc == PLOTLEFT || loc == PLOTRIGHT );

  DataView & view = dynamic_cast < DataView & > ( base );
  const Rect & draw_rect = view.getMarginRect ();

  double tick_length = 0.05 * draw_rect.getWidth ();
  tick_length = min ( tick_length, 8. );

  vector< double > xv;
  vector< double > yv; 

  const vector< AxisTick > & ticks = axisModelY.getTicks ();
  unsigned int