ErrorBarRep.cxx

Go to the documentation of this file.

#ifdef _MSC_VER
// include max() and min() missing from MicroSoft Visual C++
#include "msdevstudio/MSconfig.h"
#endif //_MSC_VER

#include "ErrorBarRep.h"

#include "datasrcs/DataPointTuple.h"
#include "datasrcs/DataSource.h"
#include "graphics/ViewBase.h"
#include "transforms/BinaryTransform.h"

#include <cassert>

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

using namespace hippodraw;

ErrorBarRep::ErrorBarRep ( )
  : RepBase ( "ErrorBar", 0 ),
    m_x_flag ( false ),
    m_y_flag ( false ),
    m_x_cap ( 0 ),
    m_y_cap ( 0 )
{
}

ErrorBarRep::~ErrorBarRep()
{
}

RepBase * ErrorBarRep::clone()
{
  return new ErrorBarRep( *this );
}

void ErrorBarRep::setXError ( bool flag )
{
  m_x_flag = flag;
}

void ErrorBarRep::setYError ( bool flag )
{
  m_y_flag = flag;
}

void ErrorBarRep::drawXError ( double x, double y, double error,
                               ViewBase & vb, const TransformBase & tb )
{
  try {
    const BinaryTransform & t 
      = dynamic_cast < const BinaryTransform & > ( tb );

    double bull;
    if( !m_x_cap ){

      double thi = m_y_range.high();
      double tlo = m_y_range.low();
      t.transform( bull, thi );
      t.transform( bull, tlo );

      Range new_range( tlo, thi );
      m_y_range = new_range;
      m_x_cap = m_y_range.length() * 0.01;
    }

    double xhi = x + error; //0.5 * error;
    double xlo = x - error; //0.5 * error;

    t.transform( x, y );
    t.transform( xlo, bull );
    t.transform( xhi, bull );

    // The line.
    m_x_err.push_back ( xhi );
    m_y_err.push_back ( y );
    m_x_err.push_back ( xlo );
    m_y_err.push_back ( y );

    // The right cap.
    m_x_err.push_back ( xhi );
    m_x_err.push_back ( xhi );
    m_y_err.push_back ( y + m_x_cap );
    m_y_err.push_back ( y - m_x_cap );

    // The left cap.
    m_x_err.push_back ( xlo );
    m_x_err.push_back ( xlo );
    m_y_err.push_back ( y + m_x_cap );
    m_y_err.push_back ( y - m_x_cap );
  }
  catch ( ... ) {
    assert ( false );
  }
}

void ErrorBarRep::drawYError ( double x, double y, double error,
                               ViewBase & vb, const TransformBase & tb )
{
  try {
    const BinaryTransform & t 
      = dynamic_cast < const BinaryTransform & > ( tb );

    double bull = 0.0;
    if( !m_y_cap ){

      double thi = m_x_range.high();
      double tlo = m_x_range.low();
      t.transform( thi, bull );
      t.transform( tlo, bull );

      Range new_range( tlo, thi );
      m_x_range = new_range;
      m_y_cap = m_x_range.length() * 0.01;
    }

    double yhi = y + error; //0.5 * error;
    double ylo = y - error; //0.5 * error;

    t.transform( x, y );
    t.transform( bull, ylo );
    t.transform( bull, yhi );

    // The line.
    m_x_err.push_back ( x );
    m_y_err.push_back ( yhi );
    m_x_err.push_back ( x );
    m_y_err.push_back ( ylo );

    // The top cap.
    m_x_err.push_back ( x + m_y_cap );
    m_y_err.push_back ( yhi );
    m_x_err.push_back ( x - m_y_cap );
    m_y_err.push_back ( yhi );

    // The bottom cap.
    m_x_err.push_back ( x + m_y_cap );
    m_y_err.push_back ( ylo );
    m_x_err.push_back ( x - m_y_cap );
    m_y_err.push_back ( ylo );
  }
  catch ( ... ) {
    assert ( false );
  }
}
namespace dp = hippodraw::DataPoint2DTuple;

void
ErrorBarRep::
drawProjectedValues ( const DataSource * ntuple,
                      TransformBase * transform,
                      ViewBase * view )
{
  if ( m_x_flag == false &&
       m_y_flag == false ) return;

  unsigned int size = ntuple -> rows ();
  if ( size == 0 ) return;

  m_x_err.clear ();
  m_y_err.clear ();

  unsigned int new_size = 0;
  if ( m_x_flag ) {
    new_size += 6 * size;
  }
  if ( m_y_flag ) {
    new_size += 6 * size;
  }

  m_x_err.reserve ( new_size );
  m_y_err.reserve ( new_size );

  getRanges ( ntuple );

  for ( unsigned int i = 0; i < size; i++ ) {
    const vector < double > & row = ntuple -> getRow ( i );
    double x = row [ dp::X ];
    double y = row [ dp::Y ];

    if ( m_x_flag == true ) {
      double err = row [ dp::XERR ];
      drawXError ( x, y, err, *view, *transform );
    }

    if ( m_y_flag == true ) {
      double err = row [ dp::YERR ];
      drawYError ( x, y, err, *view, *transform );
    }
  }

  const HippoRectangle & user_rect = view -> getUserRect ();
  user_rect.makeInBounds ( m_x_err, m_y_err );

  const Color & cur_color = color ();
  view -> drawLines ( m_x_err, m_y_err, Line::Solid, cur_color, m_size );
  m_x_cap = m_y_cap = 0;
}

void
ErrorBarRep::
getRanges ( const DataSource * ntuple )
{
  const vector < double > & x = ntuple -> getColumn ( dp::X );
  const vector < double > & y = ntuple -> getColumn ( dp::Y );

  m_x_range = Range ( x );
  m_y_range = Range ( y );
}

---