Bins2DBase.cxx
Go to the documentation of this file.
1 
13 #ifdef _MSC_VER
14 // Include max() and min() missing from MicroSoft Visual C++.
15 #include "msdevstudio/MSconfig.h"
16 #endif
17 
18 #include "Bins2DBase.h"
19 
20 #include "BinnerAxis.h"
21 
22 #include "datasrcs/NTuple.h"
23 
24 #include <numeric>
25 
26 #include <cassert>
27 
28 using std::string;
29 using std::vector;
30 
31 
32 using namespace hippodraw;
33 
34 Bins2DBase::Bins2DBase ( const char * name )
35  : BinsBase ( name ),
36  binner_axisX ( 0 ),
37  binner_axisY ( 0 )
38 {
39 }
40 
42  : BinsBase( binner ),
43  binner_axisX ( 0 ),
44  binner_axisY ( 0 ),
45  m_data ( binner.m_data )
46 {
47  if ( binner.binner_axisX != 0 ) {
48  binner_axisX = binner.binner_axisX->clone ();
49  }
50 
51  if ( binner.binner_axisY != 0 ) {
52  binner_axisY = binner.binner_axisY->clone ();
53  }
54 
55  m_values_dirty = true;
56 }
57 
59 {
60  if ( binner_axisX ) delete binner_axisX;
61  if ( binner_axisY ) delete binner_axisY;
62 }
63 
64 int
67 {
68  return 2;
69 }
70 
72 {
73  int nbx = numberOfBins ( Axes::X );
74  int nby = numberOfBins ( Axes::Y );
75 
76  if ( nbx == 0 ||
77  nby == 0 ) return;
78 
79  resize ( nbx, nby );
80 }
81 
82 const BinnerAxis *
85 {
86  assert ( axis == Axes::X ||
87  axis == Axes::Y );
88 
89  if ( axis == Axes::X ) return binner_axisX;
90  // else Y
91  return binner_axisY;
92 }
93 
94 
95 void
98 {
99  assert ( axis == Axes::X || axis == Axes::Y );
100 
101  if ( axis == Axes::X ) {
102  if ( binner_axisX ) delete binner_axisX;
103  binner_axisX = binner;
104  }
105  else { // else Y
106  if ( binner_axisY ) delete binner_axisY;
107  binner_axisY = binner;
108  }
109  resize ();
110 
111  m_values_dirty = true;
112 }
113 
114 double
117 {
118  if ( axis == Axes::X ) return binner_axisX->axisGetLow();
119  if ( axis == Axes::Y ) return binner_axisY->axisGetLow();
120 
121  assert ( false );
122  return 0.0;
123 }
124 
125 void
128 {
129  assert ( axis == Axes::X || axis == Axes::Y );
130 
131  if ( axis == Axes::X ) {
133 
134  if ( numberOfBins ( Axes::Y ) > 0 ) {
136  }
137  }
138  else { // Y
140  }
141 
143 }
144 
146 {
147  return m_num_bins;
148 }
149 
150 int
153 {
154  assert ( axis == Axes::X || axis == Axes::Y );
155 
156  if ( axis == Axes::X &&
157  binner_axisX != 0 ) return binner_axisX->axisNumberOfBins();
158  // else Y
159  if ( binner_axisY != 0 ) return binner_axisY->axisNumberOfBins();
160 
161  return 0;
162 }
163 
164 int Bins2DBase::binNumberX( double x ) const
165 {
166  return binner_axisX->axisBinNumber( x );
167 }
168 
169 int Bins2DBase::binNumberY( double y ) const
170 {
171  return binner_axisY->axisBinNumber( y );
172 }
173 
174 double
177 {
178  assert ( axis == Axes::X || axis == Axes::Y );
179 
180  if ( axis == Axes::X ) return binner_axisX->getConstWid();
181  // else Y
182  return binner_axisY->getConstWid ();
183 }
184 
185 double Bins2DBase::binWidthX ( int i ) const
186 {
187  return binner_axisX->axisBinWidth( i );
188 }
189 
190 double Bins2DBase::binWidthY ( int i ) const
191 {
192  return binner_axisY->axisBinWidth( i );
193 }
194 
195 bool
197 {
199 }
200 
201 double
203 {
204  if ( binner_axisX->hasEqualWidths () == false ||
205  binner_axisY->hasEqualWidths () == false ) {
206  return 1.0;
207  }
208 
209  double width_x = binner_axisX->axisBinWidth ( 1 );
210  double width_y = binner_axisY->axisBinWidth ( 1 );
211 
212  return width_x * width_y;
213 }
214 
215 const Range &
217 setBinWidth ( hippodraw::Axes::Type axis, double width )
218 {
219  assert ( axis == Axes::X || axis == Axes::Y );
220  assert ( width > 0.0 );
221 
222  BinnerAxis * binner = 0;
223  if ( axis == Axes::X ) binner = binner_axisX;
224  else binner = binner_axisY;
225 
226  const Range & range = binner->setBinWidth ( width );
227 
228  resize ();
229  m_values_dirty = true;
230 
231  return range;
232 }
233 
234 double
236 calcBinWidth ( Axes::Type axis, int parm, bool dragging ) const
237 {
238  double new_width = -1.0;
239 
240  if ( axis == Axes::X ) {
241  new_width = binner_axisX->calcBinWidth ( parm, dragging );
242  }
243  else { // "Y"
244  new_width = binner_axisY->calcBinWidth ( parm, dragging );
245  }
246 
247  return new_width;
248 }
249 
250 double
251 Bins2DBase::calcOffset ( const std::string & axis,
252  int parm,
253  bool dragging ) const
254 {
255  if ( axis == "X" ) {
256  return binner_axisX->calcOffset ( parm, dragging );
257  }
258  //else "Y"
259  return binner_axisY->calcOffset ( parm, dragging );
260 }
261 
262 double
265 {
266  assert ( axis == Axes::X || axis == Axes::Y );
267 
268  if( axis == Axes::X ) return binner_axisX->getOffset();
269  // else Y
270  return binner_axisY->getOffset();
271 }
272 
273 void
275 setOffset ( hippodraw::Axes::Type axis, double offset )
276 {
277  assert ( axis == Axes::X || axis == Axes::Y );
278 
279  BinnerAxis * binner = 0;
280  if ( axis == Axes::X ) binner = binner_axisX;
281  else binner = binner_axisY;
282 
283  binner->setOffset( offset );
284 
285  m_values_dirty = true;
286 }
287 
288 const Range &
290 setRange ( hippodraw::Axes::Type axis, const Range & range, bool hold_width )
291 {
292  assert ( axis == Axes::X || axis == Axes::Y );
293 
294  BinnerAxis * binner = 0;
295  if ( axis == Axes::X ) {
296  binner = binner_axisX;
297  } else {
298  binner = binner_axisY;
299  }
300  const Range & new_range = binner->setRange ( range, hold_width );
301  resize ();
302 
303  return new_range;
304 }
305 
306 /* virtual */
307 const Range &
310 {
311  assert ( axis == Axes::X || axis == Axes::Y );
312 
313  BinnerAxis * binner = 0;
314  if ( axis == Axes::X ) {
315  binner = binner_axisX;
316  } else {
317  binner = binner_axisY;
318  }
319 
320  return binner->getRange();
321 }
322 
323 
329 void
330 Bins2DBase::resize ( int nx, int ny )
331 {
332  // The following is necessary in order to prevent a memory leak
334 
335  setNumberOfBins ( Axes::X, nx );
336  setNumberOfBins ( Axes::Y, ny );
337 
338  m_values_dirty = true;
339 }
340 
342 {
343  double sum = 0.0;
344  for ( unsigned int i = 1; i < m_data.size () -1; i++ ) {
345  sum += std::accumulate ( m_data[i].begin()+1, m_data[i].end()-1, 0.0 );
346  }
347 
348  return static_cast < int > ( sum );
349 }
350 
352 {
353  return -1;
354 }
355 
357 {
358  return -1;
359 }
360 
361 
362 NTuple *
364 prepareNTuple ( unsigned int rows ) const
365 {
366  unsigned int columns = 6;
367  NTuple * ntuple = new NTuple ( columns );
368  ntuple -> reserve ( rows );
369 
370  // note: using setLabelAt instead of setLables(...) save 10KB of code
371  ntuple -> setLabelAt ( "X", 0 );
372  ntuple -> setLabelAt ( "Y", 0 );
373  ntuple -> setLabelAt ( "Value", 0 );
374  ntuple -> setLabelAt ( "Width", 0 );
375  ntuple -> setLabelAt ( "Height", 0 );
376  ntuple -> setLabelAt ( "Error", 0 );
377 
378  return ntuple;
379 }

Generated for HippoDraw Class Library by doxygen