XyPlotter.cxx

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
#include "config.h"
#else
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif
#endif

#include "XyPlotter.h"

#include "CompositePlotter.h"

#include "axes/AxisModelBase.h"
#include "datareps/DataRep.h"
#include "datasrcs/NTuple.h"
#include "datasrcs/TupleCut.h"

#include "graphics/ViewBase.h"

#include "projectors/ProjectorBase.h"
#include "reps/AxisRep2D.h"
#include "reps/AxisRepColor.h"
#include "reps/RepBase.h"

#include <cassert>

using namespace hippodraw;

#ifdef ITERATOR_MEMBER_DEFECT
using namespace std;
#else
using std::list;
using std::string;
using std::vector;
#endif

XyPlotter::XyPlotter (  const std::string & name  )
  : PlotterBase ( name )
{
  m_plotter = new CompositePlotter ();
  m_plotters.push_back ( m_plotter );
  m_axis_rep = new AxisRep2D ();
}

XyPlotter::XyPlotter ( const XyPlotter & plotter )
  : PlotterBase ( plotter )
{
  m_plotter = plotter.m_plotter -> clone ();
  m_plotters.push_back ( m_plotter );
  m_axis_rep = new AxisRep2D ();
  m_plotter -> setAllAxisModels ();
}

XyPlotter::~XyPlotter()
{
  PlotterList_t ::iterator first = m_plotters.begin();
  while ( first != m_plotters.end () ) {
    delete *first++;
  }
  delete m_axis_rep;
}

PlotterBase * XyPlotter::clone()
{
  return new XyPlotter( *this );
}

void
XyPlotter::
checkAutoScale ()
{
  PlotterList_t::size_type size = m_plotters.size ();

  bool yes = false;
  for ( PlotterList_t::size_type i = 0; i < size; i++ ) {
    CompositePlotter * plotter = m_plotters [ i ];
    bool y = plotter -> checkAutoScale ();
    yes |= y;
  }

  if ( yes ) {
    CompositePlotter * plotter = m_plotters.front ();
    AxisModelBase * model = plotter -> getAxisModel ( Axes::X );
    model -> setEmpty ();
    for ( PlotterList_t::size_type i = 0; i < size; i++ ) {
      plotter = m_plotters [ i ];
      plotter -> autoScale ( model, Axes::X );
      plotter -> autoScale ( Axes::Y );
      if ( plotter -> hasAxis ( Axes::Z ) &&
           plotter -> isAutoRanging ( Axes::Z ) ) {
        plotter -> autoScale ( Axes::Z );
      }
      plotter -> setAutoScaled (  true );
    }
  }
}

void
XyPlotter::
prepareMarginRect ( ViewBase * view )
{
  const HippoRectangle draw = view->getDrawRect();
  float width = draw.getWidth();
  float height = draw.getHeight();
    
  float marginXMin = width / 5.0f;
  float marginXMax = width * 9.0 / 10.0;
  float marginYMin = height * 5.0 / 6.0;
  float marginYMax = height / 8.0;

  if ( hasAxis ( Axes::Z ) == true ) {
    // For the color bar.
    marginYMin -= ( marginYMin - marginYMax ) * 0.1; 
  }

  float marginWidth  = marginXMax - marginXMin + 1.0;
  float marginHeight = marginYMin - marginYMax + 1.0;
  
  double aspect_ratio = getAspectRatio ();
  view -> initPlot( aspect_ratio ); 

  if ( aspect_ratio > 0.0 ) {
    marginHeight = marginWidth / aspect_ratio;
  }
  
  m_margin_rect.setRect( marginXMin, height - marginYMin,
                         marginWidth, marginHeight ); // taken from C code

}

void
XyPlotter::
prepareToDraw ( )
{
  PlotterList_t::size_type size = m_plotters.size ();

  for ( PlotterList_t::size_type i = 0; i < size; i++ ) {
    CompositePlotter * plotter = m_plotters [ i ];
    plotter -> prepareToDraw ();
  }

}

void XyPlotter::drawIn ( ViewBase * view )
{
  checkAutoScale ();
  prepareToDraw ();
  prepareMarginRect ( view );

  drawProjValues ( view );

  m_axis_rep->beginPlot ( *view );
  bool do_y = m_plotters.size() == 1;
  if ( m_active_index >= 0 ) do_y |= true;
  m_user_rect = m_plotter -> calcUserRectangle ();
  calcAxisRatios ( m_plotter );
  m_plotter -> drawAxisRep ( m_axis_rep, view, do_y, true );

  /* Draws last because it uses a larger font. */
  m_axis_rep->drawTitle( *view, ( m_title == "%t" ) ?
                         getTitle () : m_title );
}

void
XyPlotter::
drawCrossHairs ( ViewBase * view )
{
  TransformBase * transform = getTransform ();

  m_axis_rep->drawCrossHairs ( m_crossX, m_crossY, *transform, *view );
}

float XyPlotter::userToMarginColor ( double c ) const
{
  return m_margin_rect.getX () + ( c - m_user_rect.getZ () ) * m_z_ratio;
}

NTuple *
XyPlotter::
createNTuple () const
{
  NTuple * ntuple = m_plotter -> createNTuple ();

  const string & label_x = getLabel ( Axes::X );
  ntuple -> setLabelAt ( label_x, 0 );
  if ( m_plotter -> hasAxis ( Axes::Z ) ) {
    const string & label_y = getLabel ( Axes::Y );
    ntuple -> setLabelAt ( label_y, 1 );
    const string & label_z = getLabel ( Axes::Z );
    ntuple -> setLabelAt ( label_z, 2 );
  }
  else {
    ProjectorBase * projector = activeProjector ();
    const string & label_y = projector -> getYLabel ( true );
    ntuple -> setLabelAt ( label_y, 1 );
  }
  return ntuple;
}

bool
XyPlotter::
wantsPixmap ( ) const
{
  return m_plotter -> hasAxis ( Axes::Z );
}

void
XyPlotter::
setEnableZ ( bool yes )
{
  m_plotter -> setEnableZ ( yes );

  assert ( m_axis_rep );
  delete m_axis_rep;
  m_axis_rep = new AxisRepColor ();
}

void
XyPlotter::
setLabelFont ( FontBase* font, hippodraw::Axes::Type axes )
{
  if( axes == hippodraw::Axes::X )
    m_axis_rep -> setXLabelFont( font );
  else if( axes == hippodraw::Axes::Y )
    m_axis_rep -> setYLabelFont( font );
  else if( axes == hippodraw::Axes::Z )
    m_axis_rep -> setZLabelFont( font );
}

FontBase*
XyPlotter::
labelFont ( hippodraw::Axes::Type axes ) const
{
  if( axes == hippodraw::Axes::X )
    return m_axis_rep -> xLabelFont();
  else if( axes == hippodraw::Axes::Y )
    return m_axis_rep -> yLabelFont();
  else if( axes == hippodraw::Axes::Z )
    return m_axis_rep -> zLabelFont();

  return 0;
}


void
XyPlotter::
setTitleFont( FontBase* font )
{
  m_axis_rep -> setTitleFont( font );
}
        

const FontBase *
XyPlotter::
titleFont( ) const
{
  return m_axis_rep -> titleFont();
}

void
XyPlotter::
setActivePlot ( int index, bool redraw )
{
  m_active_index = index;
  bool done = false;
  PlotterList_t::iterator first = m_plotters.begin();
  while ( first != m_plotters.end () ) {
    CompositePlotter * plotter = *first++;
    if ( index < 0 ) {
      plotter -> setActivePlot ( -1, redraw );
      continue;
    }
    else {
      int num = plotter -> getNumDataReps ();
      if ( index < num && 
           done == false ) {
        plotter -> setActivePlot ( index, redraw );
        m_plotter = plotter;
        done = true;
      }
      else {
        plotter -> setActivePlot ( -2, redraw );
        index -= num;
      }
    }
  }

}

int
XyPlotter::
activePlotIndex () const
{
  return m_active_index;
}

void
XyPlotter::
addDataRep ( DataRep * rep )
{
  m_plotter -> addDataRep ( rep );
  rep -> addObserver ( this );

  int number = m_plotter -> getNumDataReps ();
  if ( number == 1 ) m_active_index = 0;
  else m_active_index = -1;

  notifyObservers ();
}

void
XyPlotter::
addDataRepStacked ( DataRep * rep )
{
  m_plotter = new CompositePlotter ();
  m_plotters.push_back ( m_plotter );
  addDataRep ( rep );

  CompositePlotter * plotter = m_plotters.front ();
  AxisModelBase * model = plotter -> getAxisModel ( Axes::X );
  m_plotter -> setAxisModel ( model, Axes::X );

  m_active_index = -1;

  notifyObservers ();
}

void
XyPlotter::
removeDataRep ( DataRep * rep )
{
  m_plotter -> removeDataRep ( rep );
  notifyObservers ();
}

void
XyPlotter::
autoScale ()
{
  m_plotter -> autoScale ();
  notifyObservers ();
}

void
XyPlotter::
setValueRep ( BinToColor * rep )
{
  m_plotter -> setValueRep ( rep );
  notifyObservers ();
}

void
XyPlotter::
setAutoRanging ( bool flag )
{
  m_plotter -> setAutoRanging ( flag );
  if ( flag == true ) notifyObservers ();
}

void
XyPlotter::
setAutoRanging ( hippodraw::Axes::Type axis, bool flag )
{
  m_plotter -> setAutoRanging ( axis, flag );
  if ( flag == true ) notifyObservers ();
}

void
XyPlotter::
setTransform ( TransformBase * transform )
{
  m_plotter -> setTransform ( transform );
  notifyObservers ();
}

float
XyPlotter::
userToMarginX ( double x ) const
{
  return m_margin_rect.getX () + ( x - m_user_rect.getX () ) * m_x_ratio;
}

float
XyPlotter::
userToMarginY ( double y ) const
{
  return m_margin_rect.getY () + ( y - m_user_rect.getY () ) * m_y_ratio;
}

float
XyPlotter::
userToInvertedMarginY ( double y ) const
{
  return m_margin_rect.getY () 
    + m_margin_rect.getHeight ()
    - ( y - m_user_rect.getY () ) * m_y_ratio;
}

double 
XyPlotter::
marginToUserX ( double x ) const
{
  return m_user_rect.getX() + ( x - m_margin_rect.getX() ) / m_x_ratio;
}

double
XyPlotter::
marginToUserY ( double y ) const
{
  return m_user_rect.getY() + ( y - m_margin_rect.getY() ) / m_y_ratio;
}

double
XyPlotter::
marginToInvertedUserY ( double y ) const
{
  return m_user_rect.getY() + 
    ( m_margin_rect.getY() + m_margin_rect.getHeight() - y ) / m_y_ratio;  
}

void
XyPlotter::
marginToUserXY ( double mx, double my, bool scaled,
                 double & ux, double & uy ) const
{
  double x = marginToUserX ( mx );
  double y = marginToUserY ( my );
  m_plotter -> toUserXY ( x, y, scaled, ux, uy );
}

NTuple *
XyPlotter::
createPickTuple ()
{
  NTuple * ntuple =  m_plotter -> createPickTuple ();

  string name ( "Pick table for " );
  const string & title = getTitle ();
  name += title;
  ntuple -> setName ( name );
  ntuple -> setTitle ( name );

  return ntuple;
}

void
XyPlotter::
fillPickedPoint ( double mx, double my, 
                  std::vector < double > & picked ) const
{
  double x = marginToUserX ( mx );
  double y = marginToInvertedUserY ( my );

  m_plotter -> fillPickedPoint ( x, y, picked );
}

void
XyPlotter::
setLowRange ( hippodraw::Axes::Type  type,
              int parm, bool dragging )
{
  m_plotter -> setLowRange ( type, parm, dragging );
  notifyObservers ();
}

void
XyPlotter::
setHighRange ( hippodraw::Axes::Type type,
               int parm, bool dragging )
{
  m_plotter -> setHighRange ( type, parm, dragging );
  notifyObservers ();
}

void
XyPlotter::
setScaling ( hippodraw::Axes::Type axis, bool on )
{
  m_plotter -> setScaling ( axis, on );
  notifyObservers ();
}

double
XyPlotter::
getAspectRatio () const
{
  double ratio = m_aspect_ratio;
  PlotterList_t::size_type size = m_plotters.size ();
  if ( ratio == 0.0 ) {
    for ( PlotterList_t::size_type i = 0; i < size; i++ ) {
      CompositePlotter * plotter = m_plotters [ i ];
      double r = plotter -> getAspectRatio ();

      if ( r != 0.0 ) {
        ratio = r;
        break;
      }
    }
  }

  return ratio;
}

void
XyPlotter::
update ()
{
  m_plotter -> update ();
}

void
XyPlotter::
setRepresentation ( RepBase * rep )
{
  m_plotter -> setRepresentation ( rep );
}

RepBase *
XyPlotter::
representation () const
{
  return m_plotter -> representation ();
}

AxisModelBase *
XyPlotter::
getAxisModel ( hippodraw::Axes::Type axis ) const
{
  return m_plotter -> getAxisModel ( axis );
}

void
XyPlotter::
setAxisModel ( AxisModelBase * model, hippodraw::Axes::Type axis )
{
  m_plotter -> setAxisModel ( model, axis );
}

void
XyPlotter::
setErrorDisplay ( hippodraw::Axes::Type axis, bool yes )
{
  m_plotter -> setErrorDisplay ( axis, yes );
}

bool
XyPlotter::
errorDisplay ( hippodraw::Axes::Type axis ) const
{
  return m_plotter -> errorDisplay ( axis );
}

void
XyPlotter::
setRepColor ( const Color & color )
{
  m_plotter -> setRepColor ( color );
}

const Color &
XyPlotter::
repColor () const
{
  return m_plotter -> repColor ();
}

void
XyPlotter::
calcAxisRatios ( const CompositePlotter * plotter )
{
  m_user_rect = plotter -> calcUserRectangle ( );

  m_x_ratio = m_margin_rect.getWidth ()  / m_user_rect.getWidth ();
  m_y_ratio = m_margin_rect.getHeight () / m_user_rect.getHeight ();
  if ( m_plotter -> hasAxis ( Axes::Z ) ) {
    m_z_ratio = m_margin_rect.getWidth ()  / m_user_rect.getDepth ();
  }
}

void
XyPlotter::
drawProjValues ( ViewBase * view )
{
  PlotterList_t::iterator first = m_plotters.begin();

  while ( first != m_plotters.end () ) {
    CompositePlotter * plotter = *first++;
    calcAxisRatios ( plotter );
    plotter -> drawProjValues ( view );
  }
}

bool
XyPlotter::
hasAutoScaled () const
{
  return m_plotter -> hasAutoScaled ();
}

bool
XyPlotter::
hasZoomY () const
{
  int retVal = 1;
  
  for ( unsigned int i = 0; i < m_plotters.size () ; i++ )
    {
      retVal = retVal * ( m_plotters[i] -> hasZoomY () ); 
    }
  return retVal != 0;
}

bool
XyPlotter::
hasNTupleBindings () const
{
  return m_plotter -> hasNTupleBindings ();
}

void
XyPlotter::
checkAxisScaling ( )
{
  m_plotter -> checkAxisScaling ();
}

ProjectorBase *
XyPlotter::
getProjector ( int i ) const
{
  const DataRep * rep = getDataRep ( i );

  return rep -> getProjector ();
}

ProjectorBase *
XyPlotter::
activeProjector () const
{
  return m_plotter -> activeProjector ();
}

DataRep *
XyPlotter::
getDataRep ( int index ) const
{
  DataRep * rep = 0;
  PlotterList_t::const_iterator first = m_plotters.begin ();
  while ( first != m_plotters.end () ) {
    CompositePlotter * plotter = *first++;
    int num = plotter -> getNumDataReps ();
    if ( index < num ) {
      rep = plotter -> getDataRep ( index );
      break;
    }
    index -= num;
  }

  return rep;
}

DataRep *
XyPlotter::
getTarget () const
{
  DataRep * rep = 0;

  if ( m_active_index >= 0 ) {
    rep = getDataRep ( m_active_index );
  }
  else {
    PlotterList_t::const_iterator first = m_plotters.begin();
    while ( first != m_plotters.end() ) {
      const CompositePlotter * plotter = *first++;
      int number = plotter -> getNumDataReps ();
      for ( int i = 0; i < number; i++ ) {
        DataRep * r = plotter -> getDataRep ( i );
        if ( r -> isTargetable () ) {
          rep = r;
          break;
        }
      }
      if ( rep != 0 ) break;
    }
  }

  return rep;
}

int
XyPlotter::
getNumDataReps () const
{
  int number = 0;
  PlotterList_t::const_iterator first = m_plotters.begin();

  while ( first != m_plotters.end() ) {
    CompositePlotter * plotter = *first++;
    number += plotter -> getNumDataReps ();
  }

  return number;
}

bool
XyPlotter::
isTargetable () const
{
  bool yes = false;

  if ( m_active_index >= 0 ) {
    const DataRep * rep = getDataRep ( m_active_index );
    assert ( rep != 0 );
    yes = rep -> isTargetable ();
  }
  else {
    int count = 0;
    PlotterList_t::const_iterator first = m_plotters.begin();
    while ( first != m_plotters.end() ) {
      const CompositePlotter * plotter = *first++;
      int number = plotter -> getNumDataReps ();
      for ( int i = 0; i < number; i++ ) {
        const DataRep * rep = plotter -> getDataRep ( i );
        if ( rep -> isTargetable () ) count++;
      }
    }
    yes = count == 1;
  }

  return yes;
}

int
XyPlotter::
indexOf ( const DataRep * rep ) const
{
  int index = 0;
  PlotterList_t::const_iterator first = m_plotters.begin ();
  while ( first != m_plotters.end () ) {
    const CompositePlotter * plotter = *first++;
    int num = plotter -> getNumDataReps ();
    int i = plotter -> indexOf ( rep );
    if ( i >= 0 ) {
      index += i;
      break;
    }
    index += num;
  }

  return index;
}

double
XyPlotter::
getBinWidth ( hippodraw::Axes::Type axis ) const
{
  return m_plotter -> getBinWidth ( axis );
}

void
XyPlotter::
setBinWidth ( hippodraw::Axes::Type axis, double width )
{
  m_plotter -> setBinWidth ( axis, width );
}

void
XyPlotter::
reset ( )
{
  m_plotter -> reset ( );
}


const Range &
XyPlotter::
getRange ( hippodraw::Axes::Type axis, bool scaled ) const
{
  return m_plotter -> getRange ( axis, scaled );
}

void
XyPlotter::
setRange ( hippodraw::Axes::Type axis, const Range & range,
           bool scaled, bool adjust_width )
{
  m_plotter -> setRange ( axis, range, scaled, adjust_width );
}

double
XyPlotter::
getOffset ( hippodraw::Axes::Type axis ) const
{
  return m_plotter -> getOffset ( axis );
}

TransformBase *
XyPlotter::
getTransform () const
{
  return m_plotter -> getTransform ();
}

void
XyPlotter::
addValues ( const std::vector < double > & v )
{
  m_plotter -> addValues ( v );
}

const string &
XyPlotter::
getInternalLabel ( hippodraw::Axes::Type axis ) const
{
  return m_plotter -> getInternalLabel ( axis );
}

const string &
XyPlotter::
getLabel ( hippodraw::Axes::Type axis ) const
{
  return m_plotter -> getLabel ( axis );
}

void
XyPlotter::
setLabel ( hippodraw::Axes::Type axis, const std::string & value )
{
  m_plotter -> setLabel ( axis, value );
  notifyObservers ();
}

int
XyPlotter::
getNumberOfEntries () const
{
  return m_plotter -> getNumberOfEntries ();
}

double
XyPlotter::
getPosRange ( hippodraw::Axes::Type axis ) const
{
  return m_plotter -> getPosRange ( axis );
}

bool
XyPlotter::
hasAxis ( hippodraw::Axes::Type axis ) const
{
  bool yes = false;
  PlotterList_t::const_iterator first = m_plotters.begin ();

  while ( first != m_plotters.end () ) {
    CompositePlotter * plotter = *first++;
    yes |= plotter -> hasAxis ( axis );
  }

  return yes;
}

const BinToColor *
XyPlotter::
getValueRep () const
{
  return m_plotter -> getValueRep ();
}

bool
XyPlotter::
isAutoRanging ( hippodraw::Axes::Type axis ) const
{
  return m_plotter -> isAutoRanging ( axis );
}

void
XyPlotter::
matrixTranspose ( bool yes )
{
  m_plotter -> matrixTranspose ( yes );
}

DataRep *
XyPlotter::
selectedDataRep () const
{
  return m_plotter -> selectedDataRep ();
}

void
XyPlotter::
setAutoTicks ( hippodraw::Axes::Type axis, bool yes )
{
  m_plotter -> setAutoTicks ( axis, yes );
}

void
XyPlotter::
setTicks ( hippodraw::Axes::Type axis, const std::vector < AxisTick > & ticks )
{
  m_plotter -> setTicks ( axis, ticks );
}

void
XyPlotter::
setNumberOfBins ( hippodraw::Axes::Type axis, unsigned int number )
{
  m_plotter -> setNumberOfBins ( axis, number );
}

void
XyPlotter::
setOffset ( hippodraw::Axes::Type axis, double offset )
{
  m_plotter -> setOffset ( axis, offset );
}

void
XyPlotter::
fillCutList ( vector < const TupleCut * > & cuts ) const
{
  PlotterList_t::const_iterator first = m_plotters.begin();
  while ( first != m_plotters.end () ) {
    const CompositePlotter * plotter = *first++;
    plotter -> fillCutList ( cuts );
  }
}

TupleCut *
XyPlotter::
getCutAt ( unsigned int i )
{
  vector < const TupleCut * > cuts;
  fillCutList ( cuts );
  TupleCut * cut = const_cast < TupleCut * > ( cuts[i] );

  return cut;
}

void
XyPlotter::
setCutRangeAt ( const Range & range, unsigned int i )
{
  TupleCut * cut = getCutAt ( i );
  cut -> setRange ( range );

  DataRep * rep = getDataRep ( 0 );
  rep -> setDirty ();

  notifyObservers ();
}

void
XyPlotter::
setCutInverted ( unsigned int i, bool yes )
{
  TupleCut * cut = getCutAt ( i );
  cut -> setInversion ( yes );

  DataRep * rep = getDataRep ( 0 );
  rep -> setDirty ();

  notifyObservers ();
}

void
XyPlotter::
setCutEnabled ( unsigned int i, bool yes )
{
  TupleCut * cut = getCutAt ( i );
  cut -> setEnabled ( yes );
  DataRep * rep = getDataRep ( 0 );
  rep -> setDirty ();

  notifyObservers ();
}

---