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
00155 if (m_need_update) {
00156 view->updateDrawRect();
00157 m_need_update = false;
00158 }
00159
00160
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
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 );
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
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 }