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

Generated for HippoDraw Class Library by doxygen