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
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
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