00001
00013 #ifdef _MSC_VER
00014 #include "msdevstudio/MSconfig.h"
00015 #endif
00016
00017 #include "BinningProjector.h"
00018
00019 #include "axes/AxisModelBase.h"
00020 #include "binners/BinsBase.h"
00021 #include "datasrcs/NTuple.h"
00022
00023 #include <cassert>
00024
00025 #ifdef ITERATOR_MEMBER_DEFECT
00026 using namespace std;
00027 #else
00028 using std::string;
00029 using std::list;
00030 using std::vector;
00031 #endif
00032
00033 using namespace hippodraw;
00034
00035 BinningProjector::BinningProjector ( unsigned int axes )
00036 : m_binner_dim ( axes ),
00037 m_binner ( 0 )
00038 {
00039 }
00040
00041 BinningProjector::BinningProjector ( const BinningProjector & projector )
00042 : ProjectorBase ( projector ),
00043 m_binner_dim ( projector.m_binner_dim ),
00044 m_binner ( 0 )
00045 {
00046 if ( projector.m_binner != 0 ) {
00047 m_binner = projector.m_binner->clone ();
00048 m_proj_values = m_binner -> createNTuple ();
00049 fillDataSource ( m_proj_values );
00050 }
00051 }
00052
00053 BinningProjector::~BinningProjector ()
00054 {
00055 if ( m_binner != 0 ) {
00056 delete m_binner;
00057 }
00058 }
00059
00060 void
00061 BinningProjector::
00062 setAxisModel ( hippodraw::Axes::Type axis, AxisModelBase * model )
00063 {
00064 ProjectorBase::setAxisModel ( axis, model );
00065 checkScaling ();
00066 }
00067
00068 void BinningProjector::prepareValues()
00069 {
00070 bool is_dirty = isDirty();
00071 if ( is_dirty ) {
00072 execute();
00073 fillDataSource ( m_proj_values );
00074 setDirty ( false );
00075 }
00076 }
00077
00078 const BinsBase *
00079 BinningProjector::
00080 getBinner ( ) const
00081 {
00082 return m_binner;
00083 }
00084
00085 void
00086 BinningProjector::
00087 setBinner ( BinsBase * bins )
00088 {
00089 if ( m_binner != 0 ) delete m_binner;
00090 m_binner = bins;
00091 if ( m_proj_values != 0 ) delete m_proj_values;
00092 m_proj_values = m_binner -> createNTuple ();
00093 }
00094
00095 void
00096 BinningProjector::
00097 setBinnerOn ( BinnerAxis * binner,
00098 hippodraw::Axes::Type type )
00099 {
00100 string axis;
00101 if ( type == Axes::X ) axis = "X";
00102 else if ( type == Axes::Y ) axis = "Y";
00103 else axis = "Z";
00104
00105 bool yes = isAxisBinned ( axis );
00106 if ( ! yes ) return;
00107
00108 m_binner->setBinnerOn ( binner, type );
00109 checkScaling ();
00110
00111 setDirty ( true );
00112 }
00113
00114 int
00115 BinningProjector::
00116 getNumberOfBins ( hippodraw::Axes::Type axis ) const
00117 {
00118 assert ( m_binner );
00119
00120 if ( axis == Axes::X ||
00121 ( m_binner_dim == 2 && axis == Axes::Y ) ) {
00122 return m_binner->numberOfBins ( axis );
00123 }
00124
00125 return ProjectorBase::getNumberOfBins ( axis );
00126 }
00127
00132 const Range &
00133 BinningProjector::
00134 setBinWidth ( hippodraw::Axes::Type axis, double width )
00135 {
00136 assert ( axis == Axes::X && width > 0. );
00137
00138 const Range & range = m_binner->setBinWidth ( Axes::X, width );
00139 checkScaling ();
00140
00141 setDirty ( true );
00142
00143 return range;
00144 }
00145
00146 const Range &
00147 BinningProjector::
00148 setBinWidth ( Axes::Type axis,
00149 int parm,
00150 bool dragging )
00151 {
00152 double new_width = m_binner->calcBinWidth ( axis, parm, dragging );
00153
00154 return setBinWidth ( axis, new_width );
00155 }
00156
00157 void BinningProjector::setOffset ( const std::string & axis,
00158 int parm,
00159 bool dragging )
00160 {
00161 if ( axis != "X" ) return;
00162
00163 double new_offset = m_binner->calcOffset ( axis, parm, dragging );
00164 setOffset ( Axes::X, new_offset );
00165
00166 setDirty ( true );
00167 }
00168
00169 void
00170 BinningProjector::
00171 setOffset ( hippodraw::Axes::Type axis, double offset )
00172 {
00173 if ( axis == Axes::Y ) return;
00174
00175 m_binner->setOffset ( Axes::X, offset );
00176 m_x_axis->setRange( m_binner->getRange ( Axes::X ), true );
00177
00178 setDirty ( true );
00179 }
00180
00181
00182 void BinningProjector:: reset ( )
00183 {
00184 }
00185
00186 double
00187 BinningProjector::
00188 getOffset ( hippodraw::Axes::Type axis ) const
00189 {
00190 assert ( axis == Axes::X || axis == Axes::Y || axis == Axes::Z );
00191
00192 if ( axis == Axes::X ||
00193 ( axis == Axes::Y && m_binner_dim == 2 ) ) {
00194 return m_binner->getOffset ( axis );
00195 }
00196
00197
00198 return 0.0;
00199 }
00200
00201 double
00202 BinningProjector::
00203 getBinWidth (hippodraw:: Axes::Type axis ) const
00204 {
00205 assert ( axis == Axes::X || axis == Axes::Y || axis == Axes::Z );
00206
00207 if ( axis == Axes::X ||
00208 ( axis == Axes::Y && m_binner_dim == 2 ) ) {
00209 return m_binner->binWidth ( axis );
00210 }
00211
00212
00213 return 0.0;
00214 }
00215
00217 void BinningProjector::execute ()
00218 {
00219 }
00220
00221 void BinningProjector::checkScaling ()
00222 {
00223
00224 }
00225
00226 double BinningProjector::getZValue ( double x, double y ) const
00227 {
00228 return m_binner->getZValue ( x, y );
00229 }
00230
00231 DataSource *
00232 BinningProjector::
00233 createNTuple () const
00234 {
00235 return m_binner->createNTuple ();
00236 }
00237
00238 void
00239 BinningProjector::
00240 fillDataSource ( DataSource * ntuple, bool ) const
00241 {
00242 m_binner -> fillDataSource ( ntuple );
00243 }
00244
00245 void
00246 BinningProjector::
00247 normalizeTo ( double number )
00248 {
00249 m_binner -> scaleNumberOfEntries ( number );
00250 }
00251
00252 void
00253 BinningProjector::
00254 setNormalizing ( bool on )
00255 {
00256 m_binner -> setEntriesScaling ( on );
00257 }
00258
00261 void
00262 BinningProjector::
00263 normalizeTo ( const ProjectorBase * target )
00264 {
00265 if ( target != 0 ) {
00266 if ( target -> isValueBinned ( ) ) {
00267 m_target = target;
00268 ProjectorBase * t = const_cast < ProjectorBase * > ( target );
00269 t -> addObserver ( this );
00270 setNormalizing ( true );
00271 normalize ();
00272 }
00273 }
00274 else {
00275 if ( m_target != 0 ) {
00276 ProjectorBase * t = const_cast < ProjectorBase * > ( m_target );
00277 t -> removeObserver ( this );
00278 setNormalizing ( false );
00279 }
00280 m_target = 0;
00281 }
00282 }
00283
00284 void
00285 BinningProjector::
00286 normalize ()
00287 {
00288 int number = m_target ->getNumberOfEntries ();
00289 double norm = number;
00290 normalizeTo ( norm );
00291
00292 setDirty ( true );
00293 }
00294
00295 void
00296 BinningProjector::
00297 update ( const Observable * object )
00298 {
00299 if ( object == m_target ) {
00300 normalize ();
00301 }
00302
00303 else notifyObservers ();
00304 }
00305
00306 void
00307 BinningProjector::
00308 willDelete ( const Observable * object )
00309 {
00310 if ( object == m_target ) {
00311 m_target = 0;
00312 setNormalizing ( false );
00313 setDirty ( true );
00314 }
00315 }
00316
00317 void
00318 BinningProjector::
00319 setBinContents ( const DataSource * source )
00320 {
00321 m_binner -> setBinContents ( source );
00322 }
00323
00324 void
00325 BinningProjector::
00326 setMinEntries ( int entries )
00327 {
00328 m_binner -> setMinEntries ( entries );
00329 setDirty ( true );
00330 }
00331
00332 int
00333 BinningProjector::
00334 getMinEntries ()
00335 {
00336 return m_binner -> getMinEntries ();
00337 }
00338
00339 bool
00340 BinningProjector::
00341 isImageConvertable () const
00342 {
00343 return m_binner_dim == 2 &&
00344 m_binner -> hasEqualWidths();
00345 }