CutController.cxx
Go to the documentation of this file.
1 
12 // for truncation warning in debug mode
13 #ifdef _MSC_VER
14 #include "msdevstudio/MSconfig.h"
15 #endif
16 
17 #include "CutController.h"
18 
19 #include "DisplayController.h"
20 #include "DataRepController.h"
21 
22 #include "datareps/DataRep.h"
24 #include "datasrcs/DataSource.h"
25 #include "datasrcs/TupleCut.h"
26 
27 #include "graphics/ViewBase.h"
28 
29 #include "plotters/PlotterBase.h"
30 #include "plotters/Cut1DPlotter.h"
31 #include "plotters/Cut2DPlotter.h"
33 
35 
36 #include <algorithm>
37 #include <stdexcept>
38 #include <utility>
39 
40 #include <cassert>
41 
42 using std::find;
43 using std::list;
44 using std::map;
45 using std::string;
46 using std::vector;
47 using std::make_pair;
48 using std::pair;
49 using std::logic_error;
50 using std::runtime_error;
51 
52 using namespace hippodraw;
53 
55 
57 {
58 }
59 
61 {
62  if ( s_instance == 0 ) {
63  s_instance = new CutController ( );
64  }
65  return s_instance;
66 }
67 
70 addCut ( PlotterBase * plotter, const std::string & label )
71 {
72  vector < string > bindings;
73  bindings.push_back ( label );
74  PlotterBase * cut = addCut ( plotter, bindings );
75 
76  return dynamic_cast < Cut1DPlotter * > ( cut );
77 }
78 
81 addCut( PlotterBase * plotter, std::vector < std::string > & bindings )
82 {
84  const DataSource * source = controller->getDataSource ( plotter, 0 );
85  const Color color ( Color::yellow );
86  CutPlotter * cut_plotter = createCut ( "", source, bindings, color );
87 
88  addCut ( cut_plotter, plotter );
89 
90  return cut_plotter;
91 }
92 
93 
94 void
96 addCut ( PlotterBase * src_plotter, PlotterBase * plotter )
97 {
98  CutPlotter * cut_plotter = dynamic_cast < CutPlotter * > ( src_plotter );
99  if ( cut_plotter == 0 ) { // not a cut
100  string what ( "Argument was not a cut" );
101  throw runtime_error ( what );
102  }
103 
104  int index = plotter->activePlotIndex ();
105  if ( index < 0 ) { // multiple reps are active
106  unsigned int size = plotter -> getNumDataReps ();
107  for ( unsigned int i = 0; i < size; i++ ) {
108  DataRep * targetrep = plotter -> getDataRep ( i );
109  if ( targetrep -> hasNTupleBindings () ) {
110  linkCutAndRep ( cut_plotter, targetrep );
111  }
112  }
113  }
114  else { // single data rep is active
115  DataRep * targetrep = plotter->getDataRep ( index );
116  if ( targetrep -> hasNTupleBindings() ) {
117  linkCutAndRep( cut_plotter, targetrep);
118  }
119  }
120 
121  CutPlotter * cp = dynamic_cast < CutPlotter * > ( plotter );
122  if ( cp != 0 ) {
123  const list < DataRep * > & targets = cp -> getCutTargets ();
124  list < DataRep * > :: const_iterator first = targets.begin();
125  while ( first != targets.end () ) {
126  DataRep * target = *first++;
127  linkCutAndRep ( cut_plotter, target );
128  }
129  }
130 }
131 
132 void
134 addCuts ( const std::vector < PlotterBase * > & cut_list,
135  PlotterBase * plotter )
136 {
137  unsigned int size = cut_list.size ();
138 
139  for ( unsigned int i = 0; i < size; i++ ) {
140  PlotterBase * pb = cut_list[i];
141  CutPlotter * cut_plotter = dynamic_cast < CutPlotter * > ( pb );
142  if ( cut_plotter != plotter ) {
143  addCut ( cut_plotter, plotter );
144  }
145  }
146 }
147 
148 void
150 linkCutAndRep( CutPlotter * cut_plotter,
151  DataRep * targetrep )
152 {
153  const vector < TupleCut > & cuts = cut_plotter -> getCuts ();
154  assert ( cuts.empty () == false );
155 
156  ProjectorBase * projbase = targetrep->getProjector ();
157  NTupleProjector * projector
158  = dynamic_cast < NTupleProjector * > ( projbase );
159  assert ( projector );
160 
161  for ( unsigned int i = 0; i < cuts.size(); i++ ) {
162  projector->addCut ( &cuts[i] );
163  }
164 
165  cut_plotter->addCutTarget ( targetrep );
166  targetrep->setDirty ();
167 }
168 
169 CutPlotter *
171 createCut ( const std::string & ,
172  const DataSource * ntuple,
173  const std::vector < std::string > & bindings,
174  const Color & color ) const
175 {
176  std::string datarepname, plottername;
177  int ndims = bindings.size();
178 
179  if( ndims == 1 )
180  {
181  datarepname = "Histogram"; // 1 D DyHistogram (Dynamic Histogram)
182  plottername = "Cut1DPlotter"; // 1 D cut plotter
183  }
184  else if( ndims == 2 )
185  {
186  datarepname = "Color Plot"; // 2 D couterpart of DyHistogram
187  plottername = "Cut2DPlotter"; // 2 D cut plotter
188  }
189 
191  DataRep * rep = controller->createDataRep ( datarepname,
192  ntuple,
193  bindings );
194  assert( rep != 0 );
195 
197  PlotterBase * pbase = pfactory->create ( plottername );
198  CutPlotter * plotter = dynamic_cast < CutPlotter * > ( pbase );
199 
200  // Add data rep and tuple cut separately.
201  plotter -> addDataRep ( rep );
202  plotter -> addTupleCut ( rep );
203 
204  plotter -> setNTuple ( ntuple );
205  plotter -> setAxisBinding ( bindings );
206  plotter -> setCutRangeFull ();
207  plotter -> setCutColor ( color );
208 
209  return plotter;
210 }
211 
213  PlotterBase * plotter )
214 {
215  CutPlotter * cut_plotter = dynamic_cast < CutPlotter * > ( cplotter );
216 
217  if ( cut_plotter != 0 ) {
218  DataRep * rep = plotter -> selectedDataRep ();
219 
220  if ( rep != 0 ) {
221  cut_plotter -> removeFromTarget ( rep );
222  setZoomPan ( cut_plotter, Axes::X, false );
223  }
224  }
225  else { // must be cut for region
226  DataRep * rep = cplotter -> selectedDataRep ();
227  rep -> removeCut ();
228  }
229 }
230 
231 void
233 fillCutList ( const std::vector < PlotterBase * > & plotter_list,
234  std::vector < CutPlotter * > & cut_list )
235 {
236  cut_list.clear ();
237  vector < PlotterBase * >::const_iterator first = plotter_list.begin();
238  while ( first != plotter_list.end() ) {
239  PlotterBase * plotter = *first++;
240  CutPlotter * cutter = dynamic_cast < CutPlotter * > ( plotter );
241  if ( cutter != 0 ) {
242  cut_list.push_back ( cutter );
243  }
244  }
245 }
246 
247 const vector < const TupleCut * > &
249 getCutList ( const DataRep * datarep ) const
250 {
251  ProjectorBase * pbase = datarep -> getProjector ();
252  NTupleProjector * projector
253  = dynamic_cast < NTupleProjector * > ( pbase );
254 
255  if ( projector == 0 ) { // then can't have cuts
256  string what ( "CutController::getCutList: ");
257  what += "DataRep does not have NTupleProjector.";
258  throw std::logic_error ( what );
259  }
260 
261  return projector -> getCutList();
262 }
263 
264 void
266 fillCutList ( const PlotterBase * plotter,
267  std::vector < PlotterBase * > & cut_list )
268 {
269  cut_list.clear();
270  int reps = plotter -> getNumDataReps ();
271  for ( int i = 0; i < reps; i++ ) {
272  const DataRep * rep = plotter -> getDataRep ( i );
273  vector < PlotterBase * > cuts;
274  fillCutList ( rep, cuts );
275  cut_list.insert ( cut_list.end(), cuts.begin(), cuts.end() );
276  }
277 }
278 
279 void
281 fillCutList ( const DataRep * datarep,
282  std::vector < PlotterBase * > & cut_list )
283 {
284  cut_list.clear ();
285 
286  const Observable::ObserverList_t & objects = datarep -> getObservers ();
287  Observable::ObserverList_t::const_iterator first = objects.begin();
288 
289  while ( first != objects.end() ) {
290  const Observer * obj = *first++;
291  const CutPlotter * plotter = dynamic_cast < const CutPlotter * > ( obj );
292  if ( plotter != 0 ) {
293  const DataRep * rep = plotter -> getDataRep ( 0 );
294  if ( rep != datarep ) {
295  CutPlotter * cp = const_cast < CutPlotter * > ( plotter );
296  cut_list.push_back ( cp );
297  }
298  }
299  }
300 }
301 
302 void
304 fillCutWeb ( const std::vector < PlotterBase * > & plotters,
305  std::vector < PlotterBase * > & web )
306 {
307  web.clear ();
308  vector < PlotterBase * > ::const_iterator first = plotters.begin ();
309 
310  while ( first != plotters.end () ) {
311  PlotterBase * plotter = *first++;
312  appendToWeb ( plotter, web );
313  }
314 }
315 
316 
317 void
320 {
321  PlotterList_t::iterator first = find ( web.begin (), web.end(),
322  plotter );
323  if ( first == web.end () ) {
324  web.push_back ( plotter );
325  int index = plotter -> activePlotIndex ();
326  if ( index < 0 ) {
327  web.clear ();
328  return;
329  }
330  DataRep * rep = plotter -> getDataRep ( index );
331  vector < PlotterBase * > cut_list;
332  fillCutList ( rep, cut_list );
333  if ( cut_list.empty () == false ) {
334  appendToWeb ( cut_list, web );
335  }
336  }
337 }
338 
339 void
342  PlotterList_t & web )
343 {
344  PlotterList_t::iterator first = find ( web.begin(), web.end(),
345  cutter );
346  if ( first == web.end () ) {
347  web.push_back ( cutter );
348  // get the targets and make recurive call
349  const list < DataRep * > & targets = cutter -> getCutTargets ();
350  list < DataRep * > ::const_iterator it = targets.begin ();
351 
352  while ( it != targets.end () ) {
353  DataRep * rep = *it++;
354  PlotterBase * plotter = findPlotter ( rep );
355  assert ( plotter );
356  appendToWeb ( plotter, web );
357  }
358  }
359 }
360 
361 void
363 appendToWeb ( const std::vector < PlotterBase * > & cutters,
364  PlotterList_t & web )
365 {
366  PlotterList_t::const_iterator first = cutters.begin ();
367  while ( first != cutters.end () ) {
368  PlotterBase * pb = *first++;
369  CutPlotter * cutter = dynamic_cast < CutPlotter * > ( pb );
370  appendToWeb ( cutter, web );
371  }
372 }
373 
374 PlotterBase *
376 findPlotter ( const DataRep * datarep )
377 {
378  const PlotterBase * plotter = 0;
379  const Observable::ObserverList_t & objects = datarep -> getObservers ();
380  Observable::ObserverList_t::const_iterator first = objects.begin();
381 
382  while ( first != objects.end () ) {
383  const Observer * obj = *first++;
384  const CutPlotter * cutter = dynamic_cast < const CutPlotter * > ( obj );
385  if ( cutter != 0 ) {
386  DataRep * plotter_rep = cutter -> getDataRep ( 0 );
387  if ( plotter_rep == datarep ) {
388  plotter = cutter;
389  break;
390  }
391  continue;
392  }
393  const XyPlotter * xyplotter = dynamic_cast < const XyPlotter * > ( obj );
394  if ( xyplotter != 0 ) {
395  plotter = xyplotter;
396  break;
397  }
398  }
399 
400  return const_cast < PlotterBase * > ( plotter );
401 }
402 
403 void
405 fillTupleCutList ( const std::vector < const ViewBase * > & views,
406  std::vector < const TupleCut * > & cut_list )
407 {
408  cut_list.clear();
409 
410 #ifdef ITERATOR_MEMBER_DEFECT
411  std::
412 #endif
413  vector < const ViewBase * >::const_iterator first = views.begin ();
414  while ( first != views.end() ) {
415  const ViewBase * view = *first++;
416  PlotterBase * pbase = view->getPlotter ();
417  Cut1DPlotter * plotter = dynamic_cast < Cut1DPlotter * > ( pbase );
418  if ( plotter == 0 ) continue;
419 
420  const vector < TupleCut > & cuts = plotter -> getCuts ();
421  for ( unsigned int i = 0; i < cuts.size(); i++ ) {
422  cut_list.push_back ( &cuts[i] );
423  }
424  }
425 }
426 
427 void
429 connectDataRep ( const std::list < ViewBase * > & targets,
430  const std::vector < const ViewBase * > & views )
431 {
432 #ifdef ITERATOR_MEMBER_DEFECT
433  std::
434 #endif
435  list < ViewBase * > :: const_iterator first = targets.begin ();
436  while( first != targets.end () )
437  {
438  ViewBase * view = *first++;
439  PlotterBase * plotter = view->getPlotter ();
440  int number = plotter -> getNumDataReps ();
441 
442  for( int i = 0; i < number; i++ )
443  {
444  DataRep * rep = plotter->getDataRep ( i );
445 
446  if ( rep->hasNTupleBindings () == false )
447  continue;
448 
449  connectDataRep ( rep, views );
450  }
451  }
452 }
453 
454 void
457  const std::vector < const ViewBase * > & views )
458 {
459  ProjectorBase * pbase = rep->getProjector ();
460  NTupleProjector * projector
461  = dynamic_cast < NTupleProjector * > ( pbase );
462 
463  if ( projector == 0 ) return; // no cuts possible.
464 
465  const vector < const TupleCut * > & cuts = projector->getCutList ();
466  if ( cuts.empty() == true ) return;
467 
468 #ifdef ITERATOR_MEMBER_DEFECT
469  std::
470 #endif
471  vector < const TupleCut * > ::const_iterator first = cuts.begin ();
472  while ( first != cuts.end() ) {
473  const TupleCut * cut = *first++;
474  connectDataRep ( cut, rep, views );
475  }
476 }
477 
478 void
480 connectDataRep ( const TupleCut * cut,
481  DataRep * rep,
482  const std::vector < const ViewBase * > & views )
483 {
484 #ifdef ITERATOR_MEMBER_DEFECT
485  std::
486 #endif
487  vector < const ViewBase * >::const_iterator first = views.begin();
488  while ( first != views.end() )
489  {
490  const ViewBase * view = *first++;
491  PlotterBase * pbase = view->getPlotter ();
492 
493  Cut1DPlotter * plotter = dynamic_cast < Cut1DPlotter * > ( pbase );
494  if ( plotter == 0 ) continue;
495 
496  const vector < TupleCut > & cuts = plotter -> getCuts ();
497  for ( unsigned int i = 0; i < cuts.size(); i++ ) {
498  if ( &cuts[i] == cut ) {
499  plotter->addCutTarget ( rep );
500  }
501  }
502  }
503 }
504 
505 const vector < PlotterBase * > &
507 getCutList ( const std::vector < PlotterBase * > & plotters,
508  const DataSource * ntuple ) const
509 {
511 
512  m_cut_list.clear ();
513  std::vector < PlotterBase * >::const_iterator it = plotters.begin();
514 
515  for ( ; it != plotters.end(); ++it )
516  {
517  PlotterBase * plotter = *it;
518  CutPlotter * cut_plotter = dynamic_cast < CutPlotter * > ( plotter );
519 
520  if ( cut_plotter != 0 ) {
521  const DataSource * cut_tuple = dc ->getDataSource ( cut_plotter, 0 );
522  if ( cut_tuple == ntuple ) {
523  m_cut_list.push_back ( cut_plotter );
524  }
525  }
526  }
527 
528  return m_cut_list;
529 }
530 
531 void
533 setZoomPan ( PlotterBase * cut_plotter, Axes::Type axis, bool yes )
534 {
535  if ( yes )
536  m_zoom_pan.push_back ( make_pair( cut_plotter, axis ) );
537  else // no
538  m_zoom_pan.remove ( make_pair( cut_plotter, axis ) );
539 }
540 
541 bool
543 isZoomPan ( const PlotterBase * cut_plotter,
544  Axes::Type axis ) const
545 {
546  bool found = false;
547 
548  list< pair< PlotterBase *, Axes::Type > >::const_iterator iter;
549 
550  for( iter = m_zoom_pan.begin(); iter != m_zoom_pan.end(); iter++ )
551  if( iter -> first == cut_plotter && iter -> second == axis )
552  found = true;
553 
554  return found;
555 }
556 
557 void
559 fillAcceptedRows ( std::vector < bool > & acceptArray,
560  const DataSource * source,
561  const std::vector < const TupleCut * > & cut_list )
562 {
563  acceptArray.clear ();
564 
565  std::size_t size = source -> rows ();
566  acceptArray.reserve ( size );
567 
568  std::size_t num_cuts = cut_list.size ();
569  for ( unsigned int i = 0; i < size; i++ )
570  {
571  // If cut is not selected, default is accept.
572  bool accept = true;
573 
574  // Check all the cuts.
575  for ( unsigned int j = 0; j < num_cuts; j++ )
576  {
577  const TupleCut * tc = cut_list[j];
578  accept = tc -> acceptRow ( source, i );
579  if (!accept) break;
580  }
581 
582  acceptArray.push_back ( accept );
583  }
584 }
585 
586 template < typename T >
587 class dequal {
589 public:
590  dequal ( const T &x ){ val = x; }
591  bool operator == ( const T & y ) const { return val - y < 1.0;}
592 };
593 
594 bool operator == ( const double & x,
595  const dequal<double> & d )
596 {
597  return d == x;
598 }
599 
600 void
602 createIdCut ( const DataSource * source, DataSource * dest )
603 {
604  const string colname = source -> getLabelAt( 0 );
605  const vector < double > & destcol = dest -> getColumn ( colname );
606  const vector < double > & srccol = source -> getColumn ( 0 );
607  const string colname_cut = colname + "_cut";
608  std::size_t dest_size = dest -> rows ();
609  vector < double > dest_cut ( dest_size, 0. );
610  for ( std::size_t i = 0; i < srccol.size (); i++ ) {
611  const double & value = srccol[i];
612  vector < double > ::const_iterator first
613  = find ( destcol.begin(), destcol.end(),
614  dequal< double> ( value ) );
615  std::size_t d = distance ( destcol.begin(), first );
616  dest_cut [d] = 1.0;
617  }
618  dest -> addColumn ( colname_cut, dest_cut );
619 }

Generated for HippoDraw Class Library by doxygen