XyPlotter.cxx
Go to the documentation of this file.
00001 
00012 #ifdef _MSC_VER
00013 #include "msdevstudio/MSconfig.h"
00014 #endif
00015 
00016 #include "XyPlotter.h"
00017 
00018 #include "CompositePlotter.h"
00019 
00020 #include "axes/AxisModelBase.h"
00021 #include "datareps/DataRep.h"
00022 #include "datasrcs/NTuple.h"
00023 #include "datasrcs/TupleCut.h"
00024 
00025 #include "graphics/ViewBase.h"
00026 
00027 #include "projectors/ProjectorBase.h"
00028 #include "transforms/PeriodicBinaryTransform.h"
00029 #include "reps/AxisRep2D.h"
00030 #include "reps/AxisRepColor.h"
00031 #include "reps/RepBase.h"
00032 
00033 #include <cassert>
00034 
00035 #ifdef ITERATOR_MEMBER_DEFECT
00036 using namespace std;
00037 #else
00038 using std::list;
00039 using std::string;
00040 using std::vector;
00041 #endif
00042 
00043 using namespace hippodraw;
00044 
00045 XyPlotter::XyPlotter (  const std::string & name  )
00046   : PlotterBase ( name )
00047 {
00048   m_plotter = new CompositePlotter ();
00049   m_plotters.push_back ( m_plotter );
00050   m_axis_rep = new AxisRep2D ();
00051   view_change_allowed = true;
00052 
00053   m_margin_top = 0.0;
00054   m_margin_bottom = 0.0;
00055   m_margin_left = 0.0;
00056   m_margin_z = 0.0;
00057 
00058   m_hammer_shape.reserve(3);
00059   m_hammer_shape.push_back(360);
00060   m_hammer_shape.push_back(180);
00061   m_hammer_shape.push_back(2);
00062 
00063 
00064   m_lambert_shape.reserve(3);
00065   m_lambert_shape.push_back(256);
00066   m_lambert_shape.push_back(256);
00067   m_lambert_shape.push_back(2);
00068   
00069   m_need_update = false;
00070 }
00071 
00072 XyPlotter::XyPlotter ( const XyPlotter & plotter )
00073   : PlotterBase ( plotter )
00074 {
00075   m_plotter = plotter.m_plotter -> clone ();
00076   m_plotters.push_back ( m_plotter );
00077   m_axis_rep = new AxisRep2D ();
00078   m_plotter -> setAllAxisModels ();
00079   view_change_allowed = true;
00080 
00081   m_margin_top = plotter.m_margin_top;
00082   m_margin_bottom = plotter.m_margin_bottom;
00083   m_margin_left = plotter.m_margin_left;
00084   m_margin_z = plotter.m_margin_z;
00085 
00086   m_hammer_shape = plotter.m_hammer_shape;
00087   m_lambert_shape = plotter.m_lambert_shape;
00088 
00089   m_need_update = plotter.m_need_update;
00090 }
00091 
00092 XyPlotter::~XyPlotter()
00093 {
00094   PlotterList_t ::iterator first = m_plotters.begin();
00095   AxisModelBase * model = (*first) -> getAxisModel ( Axes::X );
00096   while ( first != m_plotters.end () ) {
00097     delete *first++;
00098   }
00099   delete model;
00100   delete m_axis_rep;
00101 }
00102 
00103 PlotterBase * XyPlotter::clone()
00104 {
00105   return new XyPlotter( *this );
00106 }
00107 
00108 void
00109 XyPlotter::
00110 checkAutoScale ()
00111 {
00112   PlotterList_t::size_type size = m_plotters.size ();
00113 
00114   bool yes = false;
00115   for ( PlotterList_t::size_type i = 0; i < size; i++ ) {
00116     CompositePlotter * plotter = m_plotters [ i ];
00117     bool y = plotter -> checkAutoScale ();
00118     yes |= y;
00119   }
00120 
00121   if ( yes ) {
00122     CompositePlotter * plotter = m_plotters.front ();
00123     AxisModelBase * model = plotter -> getAxisModel ( Axes::X );
00124     model -> setEmpty ();
00125     for ( PlotterList_t::size_type i = 0; i < size; i++ ) {
00126       plotter = m_plotters [ i ];
00127       plotter -> autoScale ( model, Axes::X );
00128       plotter -> autoScale ( Axes::Y );
00129       if ( plotter -> hasAxis ( Axes::Z ) &&
00130            plotter -> isAutoRanging ( Axes::Z ) ) {
00131         plotter -> autoScale ( Axes::Z );
00132       }
00133       plotter -> setAutoScaled (  true );
00134     }
00135   }
00136 }
00137 
00138 void
00139 XyPlotter::
00140 prepareToDraw ( )
00141 {
00142   checkAutoScale ();
00143 
00144   PlotterList_t::size_type size = m_plotters.size ();
00145 
00146   for ( PlotterList_t::size_type i = 0; i < size; i++ ) {
00147     m_plotter = m_plotters [ i ];
00148     m_plotter -> prepareToDraw ();
00149   }
00150 }
00151 
00152 void XyPlotter::drawIn ( ViewBase * view )
00153 {
00154   // m_need_update is set by inspector. update the draw rect of the view. 
00155   if (m_need_update) {
00156     view->updateDrawRect();
00157     m_need_update = false;
00158   }
00159 
00160   // Draw values before drawing axis.
00161   drawProjValues ( view );
00162 
00163   m_axis_rep->beginPlot ( *view );
00164   bool do_y = m_plotters.size() == 1;
00165   if ( m_active_index >= 0 ) do_y |= true;
00166   m_user_rect = m_plotter -> calcUserRectangle ();
00167   m_raw_rect = m_plotter -> calcRawRectangle();
00168 
00169   /* Draws last because it uses a larger font. */
00170   m_axis_rep->drawTitle( *view, ( m_title == "%t" ) ?
00171                          getTitle () : m_title );
00172 
00173   m_plotter -> drawAxisRep ( m_axis_rep, view, do_y, true );
00174 
00175 
00176 }
00177 
00178 void
00179 XyPlotter::
00180 drawCrossHairs ( ViewBase * view )
00181 {
00182   TransformBase * transform = getTransform ();
00183 
00184   m_axis_rep->drawCrossHairs ( m_crossX, m_crossY, *transform, *view );
00185 }
00186 
00187 NTuple *
00188 XyPlotter::
00189 createNTuple () const
00190 {
00191   NTuple * ntuple = m_plotter -> createNTuple ();
00192 
00193   const string & label_x = getLabel ( Axes::X );
00194   ntuple -> setLabelAt ( label_x, 0 );
00195   if ( m_plotter -> hasAxis ( Axes::Z ) ) {
00196     const string & label_y = getLabel ( Axes::Y );
00197     ntuple -> setLabelAt ( label_y, 1 );
00198     const string & label_z = getLabel ( Axes::Z );
00199     ntuple -> setLabelAt ( label_z, 2 );
00200   }
00201   else {
00202     ProjectorBase * projector = activeProjector ();
00203     const string & label_y = projector -> getYLabel ( true );
00204     ntuple -> setLabelAt ( label_y, 1 );
00205   }
00206   return ntuple;
00207 }
00208 
00209 bool
00210 XyPlotter::
00211 wantsPixmap ( ) const
00212 {
00213   return m_plotter -> hasAxis ( Axes::Z );
00214 }
00215 
00216 void
00217 XyPlotter::
00218 setEnableZ ( bool yes )
00219 {
00220   m_plotter -> setEnableZ ( yes );
00221 
00222   assert ( m_axis_rep );
00223   delete m_axis_rep;
00224   m_axis_rep = new AxisRepColor ();
00225 }
00226 
00227 void
00228 XyPlotter::
00229 setLabelFont ( FontBase* font, hippodraw::Axes::Type axes )
00230 {
00231   if( axes == hippodraw::Axes::X )
00232     m_axis_rep -> setXLabelFont( font );
00233   else if( axes == hippodraw::Axes::Y )
00234     m_axis_rep -> setYLabelFont( font );
00235   else if( axes == hippodraw::Axes::Z )
00236     m_axis_rep -> setZLabelFont( font );
00237 }
00238 
00239 FontBase*
00240 XyPlotter::
00241 labelFont ( hippodraw::Axes::Type axes ) const
00242 {
00243   if( axes == hippodraw::Axes::X )
00244     return m_axis_rep -> xLabelFont();
00245   else if( axes == hippodraw::Axes::Y )
00246     return m_axis_rep -> yLabelFont();
00247   else if( axes == hippodraw::Axes::Z )
00248     return m_axis_rep -> zLabelFont();
00249 
00250   return 0;
00251 }
00252 
00253 
00254 void
00255 XyPlotter::
00256 setTitleFont( FontBase* font )
00257 {
00258   m_axis_rep -> setTitleFont( font );
00259 }
00260         
00261 
00262 const FontBase *
00263 XyPlotter::
00264 titleFont( ) const
00265 {
00266   return m_axis_rep -> titleFont();
00267 }
00268 
00269 void
00270 XyPlotter::
00271 setActivePlot ( int index, bool redraw )
00272 {
00273   m_active_index = index;
00274   bool done = false;
00275   PlotterList_t::iterator first = m_plotters.begin();
00276   while ( first != m_plotters.end () ) {
00277     CompositePlotter * plotter = *first++;
00278     if ( index < 0 ) {
00279       plotter -> setActivePlot ( -1, redraw );
00280       continue;
00281     }
00282     else {
00283       int num = plotter -> getNumDataReps ();
00284       if ( index < num && 
00285            done == false ) {
00286         plotter -> setActivePlot ( index, redraw );
00287         m_plotter = plotter;
00288         done = true;
00289       }
00290       else {
00291         plotter -> setActivePlot ( -2, redraw );
00292         index -= num;
00293       }
00294     }
00295   }
00296 
00297 }
00298 
00299 int
00300 XyPlotter::
00301 activePlotIndex () const
00302 {
00303   return m_active_index;
00304 }
00305 
00306 void
00307 XyPlotter::
00308 addDataRep ( DataRep * rep )
00309 {
00310   m_plotter -> addDataRep ( rep );
00311   rep -> addObserver ( this );
00312 
00313   unsigned int number = m_plotter -> getNumDataReps ();
00314   if ( number == 1 ) {
00315     m_active_index = 0;
00316   }
00317   else {
00318     m_active_index = -1;
00319   }
00320   autoScale ();
00321 
00322   notifyObservers ();
00323 }
00324 
00325 void
00326 XyPlotter::
00327 addDataRepStacked ( DataRep * rep )
00328 {
00329   m_plotter = new CompositePlotter ();
00330   m_plotters.push_back ( m_plotter );
00331   addDataRep ( rep );
00332 
00333   CompositePlotter * plotter = m_plotters.front ();
00334   AxisModelBase * model = plotter -> getAxisModel ( Axes::X );
00335   m_plotter -> setAxisModel ( model, Axes::X );
00336 
00337   m_active_index = -1;
00338 
00339   setAutoRanging ( true );
00340   autoScale ();
00341 
00342   notifyObservers ();
00343 }
00344 
00345 void
00346 XyPlotter::
00347 removeDataRep ( DataRep * rep )
00348 {
00349   m_plotter -> removeDataRep ( rep );
00350   notifyObservers ();
00351 }
00352 
00353 void
00354 XyPlotter::
00355 autoScale ()
00356 {
00357   m_plotter -> autoScale ();
00358   notifyObservers ();
00359 }
00360 
00361 void
00362 XyPlotter::
00363 setValueRep ( BinToColor * rep )
00364 {
00365   m_plotter -> setValueRep ( rep );
00366   notifyObservers ();
00367 }
00368 
00369 void
00370 XyPlotter::
00371 setAutoRanging ( bool flag )
00372 {
00373   m_plotter -> setAutoRanging ( flag );
00374   if ( flag == true ) notifyObservers ();
00375 }
00376 
00377 void
00378 XyPlotter::
00379 setReverse ( bool flag )
00380 {
00381   m_plotter -> setReverse ( flag );
00382   notifyObservers ();
00383 }
00384 
00385 
00386 void
00387 XyPlotter::
00388 setAutoRanging ( hippodraw::Axes::Type axis, bool flag )
00389 {
00390   m_plotter -> setAutoRanging ( axis, flag );
00391   if ( flag == true ) notifyObservers ();
00392 }
00393 
00394 void
00395 XyPlotter::
00396 setTransform ( TransformBase * transform )
00397 {
00398   m_plotter -> setTransform ( transform );
00399   notifyObservers ();
00400 }
00401 
00402 NTuple *
00403 XyPlotter::
00404 createPickTuple ()
00405 {
00406   NTuple * ntuple =  m_plotter -> createPickTuple ();
00407 
00408   string name ( "Pick table for " );
00409   const string & title = getTitle ();
00410   name += title;
00411   ntuple -> setName ( name );
00412   ntuple -> setTitle ( name );
00413 
00414   return ntuple;
00415 }
00416 
00417 void
00418 XyPlotter::
00419 fillPickedPointFrom ( double mx, double my, 
00420                       std::vector < double > & picked ) const
00421 {
00422   m_plotter -> fillPickedPoint ( mx, my, picked );
00423 }
00424 
00425 void
00426 XyPlotter::
00427 setLowRange ( hippodraw::Axes::Type  type,
00428               int parm, bool dragging )
00429 {
00430   m_plotter -> setLowRange ( type, parm, dragging );
00431   notifyObservers ();
00432 }
00433 
00434 void
00435 XyPlotter::
00436 setHighRange ( hippodraw::Axes::Type type,
00437                int parm, bool dragging )
00438 {
00439   m_plotter -> setHighRange ( type, parm, dragging );
00440   notifyObservers ();
00441 }
00442 
00443 void
00444 XyPlotter::
00445 setScaling ( hippodraw::Axes::Type axis, bool on )
00446 {
00447   m_plotter -> setScaling ( axis, on );
00448   notifyObservers ();
00449 }
00450 
00451 double
00452 XyPlotter::
00453 getAspectRatio () const
00454 {
00455   double ratio = m_aspect_ratio;
00456   PlotterList_t::size_type size = m_plotters.size ();
00457   if ( ratio == 0.0 ) {
00458     for ( PlotterList_t::size_type i = 0; i < size; i++ ) {
00459       CompositePlotter * plotter = m_plotters [ i ];
00460       double r = plotter -> getAspectRatio ();
00461 
00462       if ( r != 0.0 ) {
00463         ratio = r;
00464         break;
00465       }
00466     }
00467   }
00468 
00469   return ratio;
00470 }
00471 
00472 void
00473 XyPlotter::
00474 update ()
00475 {
00476   m_plotter -> update ();
00477 }
00478 
00479 void
00480 XyPlotter::
00481 setRepresentation ( RepBase * rep )
00482 {
00483   m_plotter -> setRepresentation ( rep );
00484 }
00485 
00486 RepBase *
00487 XyPlotter::
00488 representation () const
00489 {
00490   return m_plotter -> representation ();
00491 }
00492 
00493 AxisModelBase *
00494 XyPlotter::
00495 getAxisModel ( hippodraw::Axes::Type axis ) const
00496 {
00497   return m_plotter -> getAxisModel ( axis );
00498 }
00499 
00500 void
00501 XyPlotter::
00502 setAxisModel ( AxisModelBase * model, hippodraw::Axes::Type axis )
00503 {
00504   m_plotter -> setAxisModel ( model, axis );
00505 }
00506 
00507 void
00508 XyPlotter::
00509 setErrorDisplay ( hippodraw::Axes::Type axis, bool yes )
00510 {
00511   m_plotter -> setErrorDisplay ( axis, yes );
00512 }
00513 
00514 bool
00515 XyPlotter::
00516 errorDisplay ( hippodraw::Axes::Type axis ) const
00517 {
00518   return m_plotter -> errorDisplay ( axis );
00519 }
00520 
00521 void
00522 XyPlotter::
00523 setRepColor ( const Color & color )
00524 {
00525   m_plotter -> setRepColor ( color );
00526 }
00527 
00528 const Color &
00529 XyPlotter::
00530 repColor () const
00531 {
00532   int index = activePlotIndex ();
00533   if ( index < 0 ) index = 0;
00534   DataRep * rep = getDataRep ( index );
00535 
00536   return rep -> getRepColor ();
00537 }
00538 
00539 void
00540 XyPlotter::
00541 drawProjValues ( ViewBase * view )
00542 {
00543   PlotterList_t::iterator first = m_plotters.begin();
00544 
00545   while ( first != m_plotters.end () ) {
00546     m_plotter = *first++;
00547     m_user_rect = m_plotter -> calcUserRectangle ( );
00548     m_raw_rect = m_plotter -> calcRawRectangle();
00549     m_plotter -> drawProjValues ( view );
00550   }
00551 }
00552 
00553 bool
00554 XyPlotter::
00555 hasAutoScaled () const
00556 {
00557   return m_plotter -> hasAutoScaled ();
00558 }
00559 
00560 bool
00561 XyPlotter::
00562 hasZoomY () const
00563 {
00564   int retVal = 1;
00565   
00566   for ( unsigned int i = 0; i < m_plotters.size () ; i++ )
00567     {
00568       retVal = retVal * ( m_plotters[i] -> hasZoomY () ); 
00569     }
00570   return retVal != 0;
00571 }
00572 
00573 bool
00574 XyPlotter::
00575 hasNTupleBindings () const
00576 {
00577   return m_plotter -> hasNTupleBindings ();
00578 }
00579 
00580 void
00581 XyPlotter::
00582 checkAxisScaling ( )
00583 {
00584   m_plotter -> checkAxisScaling ();
00585 }
00586 
00587 ProjectorBase *
00588 XyPlotter::
00589 getProjector ( int i ) const
00590 {
00591   const DataRep * rep = getDataRep ( i );
00592 
00593   return rep -> getProjector ();
00594 }
00595 
00596 ProjectorBase *
00597 XyPlotter::
00598 activeProjector () const
00599 {
00600   return m_plotter -> activeProjector ();
00601 }
00602 
00603 DataRep *
00604 XyPlotter::
00605 getDataRep ( int index ) const
00606 {
00607   DataRep * rep = 0;
00608   PlotterList_t::const_iterator first = m_plotters.begin ();
00609   while ( first != m_plotters.end () ) {
00610     CompositePlotter * plotter = *first++;
00611     int num = plotter -> getNumDataReps ();
00612     if ( index < num ) {
00613       rep = plotter -> getDataRep ( index );
00614       break;
00615     }
00616     index -= num;
00617   }
00618 
00619   return rep;
00620 }
00621 
00622 DataRep *
00623 XyPlotter::
00624 getTarget () const
00625 {
00626   DataRep * rep = 0;
00627 
00628   if ( m_active_index >= 0 ) {
00629     rep = getDataRep ( m_active_index );
00630   }
00631   else {
00632     PlotterList_t::const_iterator first = m_plotters.begin();
00633     while ( first != m_plotters.end() ) {
00634       const CompositePlotter * plotter = *first++;
00635       int number = plotter -> getNumDataReps ();
00636       for ( int i = 0; i < number; i++ ) {
00637         DataRep * r = plotter -> getDataRep ( i );
00638         if ( r -> isTargetable () ) {
00639           rep = r;
00640           break;
00641         }
00642       }
00643       if ( rep != 0 ) break;
00644     }
00645   }
00646 
00647   return rep;
00648 }
00649 
00650 int
00651 XyPlotter::
00652 getNumDataReps () const
00653 {
00654   int number = 0;
00655   PlotterList_t::const_iterator first = m_plotters.begin();
00656 
00657   while ( first != m_plotters.end() ) {
00658     CompositePlotter * plotter = *first++;
00659     number += plotter -> getNumDataReps ();
00660   }
00661 
00662   return number;
00663 }
00664 
00665 bool
00666 XyPlotter::
00667 isTargetable () const
00668 {
00669   bool yes = false;
00670 
00671   if ( m_active_index >= 0 ) {
00672     const DataRep * rep = getDataRep ( m_active_index );
00673     assert ( rep != 0 );
00674     yes = rep -> isTargetable ();
00675   }
00676   else {
00677     int count = 0;
00678     PlotterList_t::const_iterator first = m_plotters.begin();
00679     while ( first != m_plotters.end() ) {
00680       const CompositePlotter * plotter = *first++;
00681       int number = plotter -> getNumDataReps ();
00682       for ( int i = 0; i < number; i++ ) {
00683         const DataRep * rep = plotter -> getDataRep ( i );
00684         if ( rep -> isTargetable () ) count++;
00685       }
00686     }
00687     yes = count == 1;
00688   }
00689 
00690   return yes;
00691 }
00692 
00693 int
00694 XyPlotter::
00695 indexOf ( const DataRep * rep ) const
00696 {
00697   int index = 0;
00698   PlotterList_t::const_iterator first = m_plotters.begin ();
00699   while ( first != m_plotters.end () ) {
00700     const CompositePlotter * plotter = *first++;
00701     int num = plotter -> getNumDataReps ();
00702     int i = plotter -> indexOf ( rep );
00703     if ( i >= 0 ) {
00704       index += i;
00705       break;
00706     }
00707     index += num;
00708   }
00709 
00710   return index;
00711 }
00712 
00713 double
00714 XyPlotter::
00715 getBinWidth ( hippodraw::Axes::Type axis ) const
00716 {
00717   return m_plotter -> getBinWidth ( axis );
00718 }
00719 
00720 void
00721 XyPlotter::
00722 setBinWidth ( hippodraw::Axes::Type axis, double width )
00723 {
00724   int index = activePlotIndex ();
00725 
00726   if ( index < 0 ) {
00727     PlotterList_t::iterator first = m_plotters.begin ();
00728     while ( first != m_plotters.end () ) {
00729       CompositePlotter * plotter = *first++;
00730       plotter -> setBinWidth ( axis, width );
00731     }
00732   }
00733   else {
00734     Range cur_range = getRange (axis, false );
00735     DataRep * rep = getDataRep ( index );
00736     const Range & range = rep -> setBinWidth ( axis, width );
00737     cur_range.setUnion ( range );
00738     setRange ( axis, cur_range, false, false );
00739   }
00740 }
00741 
00742 void
00743 XyPlotter::
00744 reset ( )
00745 {
00746   m_plotter -> reset ( );
00747 }
00748 
00749 const Range &
00750 XyPlotter::
00751 getRange ( hippodraw::Axes::Type axis, bool scaled ) const
00752 {
00753   return m_plotter -> getRange ( axis, scaled );
00754 }
00755 
00756 void
00757 XyPlotter::
00758 setRange ( hippodraw::Axes::Type axis, const Range & range,
00759            bool scaled, bool adjust_width )
00760 {
00761   m_plotter -> setRange ( axis, range, scaled, adjust_width );
00762 }
00763 
00764 double
00765 XyPlotter::
00766 getOffset ( hippodraw::Axes::Type axis ) const
00767 {
00768   return m_plotter -> getOffset ( axis );
00769 }
00770 
00771 TransformBase *
00772 XyPlotter::
00773 getTransform () const
00774 {
00775   return m_plotter -> getTransform ();
00776 }
00777 
00778 void
00779 XyPlotter::
00780 addValues ( const std::vector < double > & v )
00781 {
00782   m_plotter -> addValues ( v );
00783 }
00784 
00785 const string &
00786 XyPlotter::
00787 getInternalLabel ( hippodraw::Axes::Type axis ) const
00788 {
00789   return m_plotter -> getInternalLabel ( axis );
00790 }
00791 
00792 const string &
00793 XyPlotter::
00794 getLabel ( hippodraw::Axes::Type axis ) const
00795 {
00796   return m_plotter -> getLabel ( axis );
00797 }
00798 
00799 void
00800 XyPlotter::
00801 setLabel ( hippodraw::Axes::Type axis, const std::string & value )
00802 {
00803   m_plotter -> setLabel ( axis, value );
00804   notifyObservers ();
00805 }
00806 
00807 int
00808 XyPlotter::
00809 getNumberOfEntries () const
00810 {
00811   return m_plotter -> getNumberOfEntries ();
00812 }
00813 
00814 double
00815 XyPlotter::
00816 getPosRange ( hippodraw::Axes::Type axis ) const
00817 {
00818   return m_plotter -> getPosRange ( axis );
00819 }
00820 
00821 bool
00822 XyPlotter::
00823 hasAxis ( hippodraw::Axes::Type axis ) const
00824 {
00825   bool yes = false;
00826   PlotterList_t::const_iterator first = m_plotters.begin ();
00827 
00828   while ( first != m_plotters.end () ) {
00829     CompositePlotter * plotter = *first++;
00830     yes |= plotter -> hasAxis ( axis );
00831   }
00832 
00833   return yes;
00834 }
00835 
00836 const BinToColor *
00837 XyPlotter::
00838 getValueRep () const
00839 {
00840   return m_plotter -> getValueRep ();
00841 }
00842 
00843 bool
00844 XyPlotter::
00845 isAutoRanging ( hippodraw::Axes::Type axis ) const
00846 {
00847   return m_plotter -> isAutoRanging ( axis );
00848 }
00849 
00850 bool
00851 XyPlotter::
00852 isReverse ( ) const
00853 {
00854   return m_plotter -> isReverse ( );
00855 }
00856 
00857 
00858 void
00859 XyPlotter::
00860 matrixTranspose ( bool yes )
00861 {
00862   m_plotter -> matrixTranspose ( yes );
00863 }
00864 
00865 DataRep *
00866 XyPlotter::
00867 selectedDataRep () const
00868 {
00869   return m_plotter -> selectedDataRep ();
00870 }
00871 
00872 void
00873 XyPlotter::
00874 setAutoTicks ( hippodraw::Axes::Type axis, bool yes )
00875 {
00876   m_plotter -> setAutoTicks ( axis, yes );
00877 }
00878 
00879 void
00880 XyPlotter::
00881 setTicks ( hippodraw::Axes::Type axis, const std::vector < AxisTick > & ticks )
00882 {
00883   m_plotter -> setTicks ( axis, ticks );
00884 }
00885 
00886 void
00887 XyPlotter::
00888 setNumberOfBins ( hippodraw::Axes::Type axis, unsigned int number )
00889 {
00890   m_plotter -> setNumberOfBins ( axis, number );
00891 }
00892 
00893 void
00894 XyPlotter::
00895 setOffset ( hippodraw::Axes::Type axis, double offset )
00896 {
00897   m_plotter -> setOffset ( axis, offset );
00898 }
00899 
00900 void
00901 XyPlotter::
00902 fillCutList ( std::vector < const TupleCut * > & cuts ) const
00903 {
00904   PlotterList_t::const_iterator first = m_plotters.begin();
00905   while ( first != m_plotters.end () ) {
00906     const CompositePlotter * plotter = *first++;
00907     plotter -> fillCutList ( cuts );
00908   }
00909 }
00910 
00911 TupleCut *
00912 XyPlotter::
00913 getCutAt ( unsigned int i )
00914 {
00915   vector < const TupleCut * > cuts;
00916   fillCutList ( cuts );
00917   TupleCut * cut = const_cast < TupleCut * > ( cuts[i] );
00918 
00919   return cut;
00920 }
00921 
00922 void
00923 XyPlotter::
00924 setCutRangeAt ( const Range & range, unsigned int i )
00925 {
00926   TupleCut * cut = getCutAt ( i );
00927   cut -> setRange ( range );
00928 
00929   DataRep * rep = getDataRep ( 0 );
00930   rep -> setDirty ();
00931 
00932   notifyObservers ();
00933 }
00934 
00935 Range
00936 XyPlotter::
00937 getCutRange ()
00938 {
00939   TupleCut * cut = getCutAt ( 0 );
00940   Range range = cut -> getRange ();
00941   
00942   return range;
00943 }
00944 
00945 
00946 
00947 
00948 void
00949 XyPlotter::
00950 setCutInverted ( unsigned int i, bool yes )
00951 {
00952   TupleCut * cut = getCutAt ( i );
00953   cut -> setInversion ( yes );
00954 
00955   DataRep * rep = getDataRep ( 0 );
00956   rep -> setDirty ();
00957 
00958   notifyObservers ();
00959 }
00960 
00961 void
00962 XyPlotter::
00963 setCutEnabled ( unsigned int i, bool yes )
00964 {
00965   TupleCut * cut = getCutAt ( i );
00966   cut -> setEnabled ( yes );
00967   DataRep * rep = getDataRep ( 0 );
00968   rep -> setDirty ();
00969 
00970   notifyObservers ();
00971 }
00972 
00973 
00974 const std::vector <double> &
00975 XyPlotter::
00976 getZValues()
00977 {
00978   TransformBase * transform = getTransform ();
00979   ProjectorBase * proj = activeProjector ();
00980   
00981   const BinaryTransform * bt 
00982     = dynamic_cast <const BinaryTransform *> ( transform );
00983 
00984   if ( bt->isPeriodic() )
00985     {
00986       return ( proj -> getZAfterTransform (transform) );
00987     }
00988   else
00989     {
00990       return ( proj -> getZValues() );
00991     }
00992   
00993 }
00994 
00995 
00996 
00997 const std::vector < unsigned int > &
00998 XyPlotter::
00999 getShape()
01000 {
01001   TransformBase * transform = getTransform ();
01002   ProjectorBase * proj = activeProjector ();
01003   
01004   const BinaryTransform * bt 
01005     = dynamic_cast < const BinaryTransform * > ( transform );
01006   
01007   // Hammer or lambert
01008   if ( bt -> isPeriodic() )
01009     {
01010       if ( bt->aspectRatio() == 1.0 ) return m_lambert_shape;
01011       else return m_hammer_shape;
01012     }
01013   else
01014     {
01015       return ( proj -> getShape() );
01016     }
01017 }
01018 
01019 bool XyPlotter::getCutInversion ()
01020 {
01021   TupleCut * cut = getCutAt ( 0 );
01022   return cut-> getInversion ();
01023 }
01024 
01025 void XyPlotter::setBoxEdge(bool flag)
01026 {
01027   m_plotter -> setBoxEdge(flag);
01028   notifyObservers ();
01029 }
01030 
01031 bool XyPlotter::getBoxEdge ()
01032 {
01033   return m_plotter->getBoxEdge();
01034 }
01035 
01036 
01037 void XyPlotter::setShowGrid( bool flag )
01038 {
01039   m_plotter -> setShowGrid ( flag );
01040   notifyObservers ();
01041 }
01042 
01043 bool XyPlotter::getShowGrid()
01044 {
01045   return m_plotter -> getShowGrid ();
01046 }
01047 
01048 
01049 void
01050 XyPlotter::
01051 setFitsTransform ( const std::string & transform )
01052 {
01053   m_plotter -> setFitsTransform ( transform );
01054 }
01055 
01056 TransformBase *
01057 XyPlotter::
01058 getFitsTransform () const
01059 {
01060   return m_plotter -> getFitsTransform ();
01061 }
01062 
01063 void
01064 XyPlotter::
01065 setMinEntries ( int entries )
01066 {
01067   m_plotter -> setMinEntries(entries);
01068 }
01069 
01070 int
01071 XyPlotter::
01072 getMinEntries ()
01073 {
01074   return m_plotter -> getMinEntries ();
01075 }
01076 
01077 void
01078 XyPlotter::
01079 setNeedUpdate( bool isChanged )
01080 {
01081   m_need_update = isChanged;
01082 }
01083 
01084 bool
01085 XyPlotter::
01086 isImageConvertable () const
01087 {
01088   bool yes = false;
01089   if ( m_plotters.size() == 1 ) {
01090     yes = m_plotters.front() -> isImageConvertable ();
01091   }
01092 
01093   return yes;
01094 }
01095 
01096 void
01097 XyPlotter::
01098 setTopMargin( double top ) 
01099 {
01100   m_margin_top=top;
01101 }
01102 
01103 void
01104 XyPlotter::
01105 setZMargin( double z )
01106 {
01107   m_margin_z = z;
01108 }
01109 
01110 void
01111 XyPlotter::
01112 setBottomMargin(double bottom)
01113 {
01114   m_margin_bottom=bottom;
01115 }
01116 
01117 void
01118 XyPlotter::
01119 setLeftMargin(double left)
01120 {
01121   m_margin_left=left;
01122 }
01123 
01124 double
01125 XyPlotter::
01126 getTopMargin()
01127 {
01128   return m_margin_top;
01129 }
01130 
01131 double
01132 XyPlotter::
01133 getZMargin()
01134 {
01135   return m_margin_z;
01136 }
01137 
01138 
01139 double
01140 XyPlotter::
01141 getBottomMargin()
01142 {
01143   return m_margin_bottom;
01144 }
01145 
01146 double
01147 XyPlotter::
01148 getLeftMargin()
01149 {
01150   return m_margin_left;
01151 }
01152 

Generated for HippoDraw Class Library by doxygen