ProjectorBase.h

Go to the documentation of this file.

/* -*- mode: c++ -*- */

#ifndef _ProjectorBase_H_
#define _ProjectorBase_H_

#include "axes/AxesType.h"
#include "pattern/Observable.h"
#include "pattern/Observer.h"

#ifdef _MSC_VER
#include <msdevstudio/MSconfig.h>
#endif

#include <vector>

namespace hippodraw {

class AxisModelBase;
class BinsBase;
class DataSource;
class NTuple;
class Range;
class TupleCut;
class TransformBase;

class MDL_HIPPOPLOT_API ProjectorBase
  : public Observable, public Observer
{

private: 

  bool m_isDirty;

protected:

  ProjectorBase ( const ProjectorBase & projector );

  DataSource * m_proj_values;

  AxisModelBase * m_x_axis;

  AxisModelBase * m_y_axis;

  AxisModelBase * m_z_axis;

  std::string m_z_label;

  std::vector < std::string > m_pointreps;

  const ProjectorBase * m_target;

  virtual void addPointReps () = 0;

  mutable std::vector < double > m_zval;


public:
  
  ProjectorBase();

  virtual ~ProjectorBase();

  virtual ProjectorBase * clone() = 0;

  virtual void setAxisBinding ( const std::string & axis,
                                const std::string & label );

  virtual void matrixTranspose ( bool yes );

  virtual 
  void setAxisBindings ( const std::vector < std::string > & bindings );

  virtual const std::vector < std::string > & getAxisBindings () const;

  virtual bool isEmpty () const = 0;

  virtual void prepareValues ();

  virtual Range dataRangeOn ( Axes::Type ) const = 0;

  virtual Range preferredRange ( Axes::Type ) const;

  bool isDirty () const;

  virtual void setDirty ( bool value = true );

  virtual int getNumberOfBins ( Axes::Type ) const;

  virtual void setAxisModel ( Axes::Type axis, AxisModelBase * );

  virtual AxisModelBase * getAxisModel ( Axes::Type axis )const;

  virtual bool isAxisBinned ( const std::string & axis ) const;

  virtual bool isValueBinned () const;

  virtual const std::string & getTitle() const = 0;

  virtual Range valueRange () const = 0;

  virtual const Range & getRange ( Axes::Type ) const;

  virtual void setRange ( Axes::Type axis, 
                          bool const_width = true );

  virtual double getPosOn ( Axes::Type ) const = 0;

  virtual void setNumberOfBins ( Axes::Type axis, 
                                 unsigned int number );

  virtual const Range &  setBinWidth ( Axes::Type axis,
                                       double width );

  virtual const Range & setBinWidth ( Axes::Type axis, 
                                      int parm, 
                                      bool dragging );

  virtual void setOffset ( const std::string & axis, 
                           int parm, 
                           bool dragging );

  virtual void setOffset ( Axes::Type axis, double offset );


  virtual void reset ();


  virtual double getOffset ( Axes::Type axis ) const;

  virtual double getBinWidth ( Axes::Type axis ) const;

  virtual const std::string & getXLabel() const = 0;

  virtual const std::string & getYLabel ( bool flag = false ) const = 0;

  virtual const std::string & getZLabel() const;

  virtual int indexOf ( const std::string & label ) const;


  virtual int getNumberOfEntries () const = 0;

  virtual int getUnderflow () const = 0;

  virtual int getOverflow () const = 0;


  virtual double getAverage(Axes::Type axis) const;

  virtual double getRMS ( Axes::Type axis );

  virtual double getZValue ( double x, double y ) const;

  virtual void addValues ( const std::vector < double > & v );

  const std::vector < std::string > & getPointReps() const;

  virtual DataSource * createNTuple () const = 0;

  const DataSource * getProjectedValues () const;

  virtual const DataSource * createOldStyleNTuple () const;

   virtual NTuple * getNTupleAfterCuts () const;

   virtual void fillColumnAfterCuts(const std::string & column,
                                    std::vector<double> & columnData) const;

  virtual 
  NTuple * createNTupleWith ( const std::vector< TupleCut > & cut_list ) const;

  virtual bool wantsScaleFactor ( const std::string & axis ) const;

  virtual void normalizeTo ( const ProjectorBase * target );

  virtual void normalizeTo ( double norm );

  virtual void setNormalizing ( bool on );

  virtual void update ( const Observable * );

  virtual void checkScaling ();


  const std::vector <double> & getZValues();

  const std::vector <unsigned int> & getShape();

  const std::vector <double> & getZAfterTransform(TransformBase * transform);

  virtual bool hasDataSourceBindings () const;

  virtual void setMinEntries( int entries );

  virtual int getMinEntries ( );

  virtual bool isImageConvertable () const;

};

} // namespace hippodraw

#endif // _ProjectorBase_H_