Logo ROOT   6.10/09
Reference Guide
TParallelCoordVar.cxx
Go to the documentation of this file.
1 // @(#)root/treeviewer:$Id$
2 // Author: Bastien Dalla Piazza 02/08/2007
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #include "TParallelCoordVar.h"
13 #include "TParallelCoord.h"
14 #include "TParallelCoordRange.h"
15 
16 #include "Riostream.h"
17 #include "TROOT.h"
18 #include "TLatex.h"
19 #include "TLine.h"
20 #include "TVirtualPad.h"
21 #include "TMath.h"
22 #include "TH1.h"
23 #include "TStyle.h"
24 #include "TBox.h"
25 #include "TCollection.h"
26 #include "TList.h"
27 #include "TFrame.h"
28 #include "TCanvas.h"
29 #include "TMarker.h"
30 
32 
33 /** \class TParallelCoordVar
34 
35 TParallelCoord axes. Class containing a variable for the TParallelCoord.
36 
37 Options can be defined each axis separately using the right mouse click. These
38 options can be applied to every axes using the editor.
39 
40  - Axis width: If set to 0, the axis is simply a line. If higher, a color
41  histogram is drawn on the axis.
42  - Axis histogram height: If not 0, a usual bar histogram is drawn on the plot.
43 
44 The order in which the variables are drawn is essential to see the clusters. The
45 axes can be dragged to change their position. A zoom is also available. The
46 logarithm scale is also available by right clicking on the axis.
47 */
48 
49 ////////////////////////////////////////////////////////////////////////////////
50 /// Default constructor.
51 
53  :TNamed(), TAttLine(), TAttFill(kOrange+9,0)
54 {
55  Init();
56 }
57 
58 ////////////////////////////////////////////////////////////////////////////////
59 ///Destructor.
60 
62 {
63  if (fHistogram) delete fHistogram;
64  if (fRanges){
65  TIter next(fRanges);
66  TParallelCoordRange* range;
67  while((range = (TParallelCoordRange*)next())) fParallel->CleanUpSelections(range);
68  fRanges->Delete();
69  delete fRanges;
70  }
71  if (fVal) delete [] fVal;
72 }
73 
74 ////////////////////////////////////////////////////////////////////////////////
75 /// Normal constructor. By default, the title and the name are the expression
76 /// given to TTree::Draw. The name can be changed by the user (the label on the
77 /// plot) but not the title.
78 
79 TParallelCoordVar::TParallelCoordVar(Double_t *val, const char* title, Int_t id, TParallelCoord* parallel)
80  :TNamed(title,title), TAttLine(1,1,1), TAttFill(kOrange+9,3001)
81 {
82  Init();
83  fId = id;
84  fParallel = parallel;
85  fRanges = new TList();
87 
89 
90  for(Long64_t ui = 0;ui<fParallel->GetNentries();++ui) fVal[ui]=val[ui];
91 
92  GetMinMaxMean();
93  GetHistogram();
94  GetQuantiles();
95 }
96 
97 ////////////////////////////////////////////////////////////////////////////////
98 /// Add a range to the current selection on the axis.
99 
101 {
102  if (!range) {
104  if (select) {
105  range = new TParallelCoordRange(this,0,0,select);
106  fRanges->Add(range);
107  range->GetSelection()->Add(range);
108  range->Draw();
109  } else {
110  Error("AddRange","You must create a selection before adding ranges.");
111  }
112  } else {
113  fRanges->Add(range);
114  range->GetSelection()->Add(range);
115  range->Draw();
116  }
117 }
118 
119 ////////////////////////////////////////////////////////////////////////////////
120 /// Delete variables.
121 
123 {
124  fParallel->RemoveVariable(this);
125  delete this;
126 }
127 
128 ////////////////////////////////////////////////////////////////////////////////
129 /// Computes the distance from the axis.
130 
132 {
133  if(!gPad) return 9999;
134  Double_t xx = gPad->AbsPixeltoX(px);
135  Double_t yy = gPad->AbsPixeltoY(py);
136  Double_t dist = 9999;
137 
138  if (fX1==fX2) {
139  if (yy>fY1+0.01 && yy<fY2-0.01) dist = TMath::Abs(xx - fX1);
140  } else {
141  if (xx>fX1+0.01 && xx<fX2-0.01) dist = TMath::Abs(yy - fY1);
142  }
143  if (dist<=0.005) return 0;
144  else return 9999;
145 }
146 
147 ////////////////////////////////////////////////////////////////////////////////
148 /// Draw the axis.
149 
151 {
152  TIter next(fRanges);
153  TParallelCoordRange* range;
154  while ((range = (TParallelCoordRange*)next())) range->Draw();
155  AppendPad(option);
156 }
157 
158 ////////////////////////////////////////////////////////////////////////////////
159 /// Check if the entry is within the range(s) of "select". Two ranges on a
160 /// single axis are conjugated as a "or": to be selected, the entry must be in
161 /// one of the ranges.
162 
164 {
165  if (fRanges->GetSize() > 0){
166  TIter next(fRanges);
167  Bool_t inarange = kFALSE;
168  Bool_t noOwnedRange = kTRUE;
169  TParallelCoordRange *range;
170  while ((range = (TParallelCoordRange*)next())){
171  if(select->Contains(range)) {
172  noOwnedRange = kFALSE;
173  if(range->IsIn(fVal[evtidx])) inarange = kTRUE;
174  }
175  }
176  if (noOwnedRange) return kTRUE;
177  else return inarange;
178  }
179  else return kTRUE;
180 }
181 
182 ////////////////////////////////////////////////////////////////////////////////
183 /// Execute the corresponding entry.
184 
186 {
187  if (!gPad) return;
188  if (!gPad->IsEditable() && entry!=kMouseEnter) return;
189 
190  static Int_t pxold, pyold;
191  static Int_t zoom; // -1:nothing zoomed or translated, 0:translating the axis, 1:zooming
192  static Int_t pzoomold;
193  static Bool_t first = kTRUE;
194 
195  Int_t px1,px2,py1,py2,n=-1;
196  px1 = gPad->XtoAbsPixel(fX1);
197  px2 = gPad->XtoAbsPixel(fX2);
198  py1 = gPad->YtoAbsPixel(fY1);
199  py2 = gPad->YtoAbsPixel(fY2);
200 
201  if(fX1 == fX2) {
202  if(gPad->AbsPixeltoX(px)-fX1 > 0) gPad->SetCursor(kArrowVer);
203  else gPad->SetCursor(kArrowHor);
204  } else {
205  if(gPad->AbsPixeltoY(py)-fY1 > 0) gPad->SetCursor(kArrowHor);
206  else gPad->SetCursor(kArrowVer);
207  }
208 
209  gVirtualX->SetLineColor(-1);
210  switch (entry) {
211  case kButton1Down:
212  if (fX1==fX2){
213  ((TCanvas*)gPad)->Selected(gPad,fParallel,1);
214  if(gPad->AbsPixeltoX(px)-fX1 > 0){
215  zoom = 1;
216  gVirtualX->DrawLine(gPad->XtoAbsPixel(fX1-0.05),py,gPad->XtoAbsPixel(fX1+0.05),py);
217  first = kTRUE;
218  pzoomold = py;
219  } else {
220  zoom = 0;
221  gVirtualX->DrawLine(px,py1,px,py2);
222  }
223  } else {
224  if(gPad->AbsPixeltoY(py)-fY1 > 0){
225  zoom = 1;
226  gVirtualX->DrawLine(px,gPad->YtoAbsPixel(fY1-0.05),px,gPad->YtoAbsPixel(fY1+0.05));
227  first=kTRUE;
228  pzoomold = px;
229  } else {
230  zoom = 0;
231  gVirtualX->DrawLine(px1,py,px2,py);
232  }
233  }
234  pxold = px;
235  pyold = py;
236  break;
237  case kButton1Up: {
238  Double_t xx = gPad->AbsPixeltoX(px);
239  Double_t yy = gPad->AbsPixeltoY(py);
240  TFrame *frame = gPad->GetFrame();
241  if (fX1==fX2) {
242  if(zoom == 0){
243  Double_t axisSpace = (frame->GetX2() - frame->GetX1())/(fParallel->GetNvar() - 1);
244  Double_t pos = (xx - frame->GetX1())/axisSpace;
245  if (pos < 0) n = -1;
246  else n = (Int_t)pos;
247  } else {
248  Double_t min = GetValuefromXY(xx,yy);
249  Double_t max = GetValuefromXY(xx,gPad->AbsPixeltoY(pzoomold));
250  if(TMath::Abs(min-max) < 0.00001) return; // Avoid zooming if the axis is just clicked.
252  if (min>max) {
253  Double_t mem = min;
254  min = max; max = mem;
255  }
256  fParallel->SetGlobalMin(min);
257  fParallel->SetGlobalMax(max);
258  } else {
259  SetCurrentLimits(min,max);
260  }
261  }
262  } else {
263  if(zoom == 0) {
264  Double_t axisSpace = (frame->GetY2() - frame->GetY1())/(fParallel->GetNvar() - 1);
265  Double_t pos = (yy-frame->GetY1())/axisSpace;
266  if (pos < 0) n= -1;
267  else n = (Int_t)pos;
268  } else {
269  Double_t min = GetValuefromXY(xx,yy);
270  Double_t max = GetValuefromXY(gPad->AbsPixeltoX(pzoomold),yy);
271  SetCurrentLimits(min,max);
272  }
273  }
274  if(zoom == 0){
275  if (n>=0 && (UInt_t)n>=fParallel->GetNvar()) --n;
276  else if (n<fParallel->GetVarList()->IndexOf(this)) ++n;
277  fParallel->GetVarList()->Remove(this);
278  fParallel->GetVarList()->AddAt(this,n);
279  }
280  gPad->Modified();
281  break;
282  }
283  case kMouseMotion:
284  pxold=px;
285  pyold=py;
286  break;
287  case kButton1Motion:
288  if(fX1==fX2){
289  if(zoom==0){
290  gPad->SetCursor(kArrowHor);
291  gVirtualX->DrawLine(pxold,py1,pxold,py2);
292  gVirtualX->DrawLine(px,py1,px,py2);
293  } else if(zoom==1) {
294  gPad->SetCursor(kArrowVer);
295  if(!first) gVirtualX->DrawLine(gPad->XtoAbsPixel(fX1-0.05),pyold,gPad->XtoAbsPixel(fX1+0.05),pyold);
296  gVirtualX->DrawLine(gPad->XtoAbsPixel(fX1-0.05),py,gPad->XtoAbsPixel(fX1+0.05),py);
297  first = kFALSE;
298  }
299  } else {
300  if(zoom==0){
301  gPad->SetCursor(kArrowVer);
302  gVirtualX->DrawLine(px1,pyold,px2,pyold);
303  gVirtualX->DrawLine(px1,py,px2,py);
304  } else if(zoom==1){
305  gPad->SetCursor(kArrowHor);
306  if(!first) gVirtualX->DrawLine(pxold,gPad->YtoAbsPixel(fY1-0.05),pxold,gPad->YtoAbsPixel(fY1+0.05));
307  gVirtualX->DrawLine(px,gPad->YtoAbsPixel(fY1-0.05),px,gPad->YtoAbsPixel(fY1+0.05));
308  first = kFALSE;
309  }
310  }
311  pxold = px;
312  pyold = py;
313  break;
314  }
315 }
316 
317 ////////////////////////////////////////////////////////////////////////////////
318 /// Get the position of the variable on the graph for the n'th entry.
319 
321 {
322  if(fX1==fX2){
323  x = fX1;
324  if (fMinCurrent != fMaxCurrent) {
325  if (TestBit(kLogScale)) y = fY1 + (fY2 - fY1) *
327  else y = fY1 + (fY2 - fY1) *
329  } else {
330  y = fY1 + 0.5*(fY2-fY1);
331  }
332  } else {
333  y = fY1;
334  if (fMinCurrent != fMaxCurrent) {
335  if (TestBit(kLogScale)) x = fX1 + (fX2 - fX1) *
337  else x = fX1 + (fX2 - fX1) *
339  } else {
340  x = fX1 + 0.5*(fX2-fX1);
341  }
342  }
343 }
344 
345 ////////////////////////////////////////////////////////////////////////////////
346 /// Get the entry weight: The weight of an entry for a given variable
347 /// is the bin content of the histogram bin the entry is going through.
348 
350 {
351  Int_t bin = 1 + (Int_t)((fVal[evtidx] - fMinCurrent)/((fMaxCurrent-fMinCurrent)/fNbins));
352  return (Int_t)fHistogram->GetBinContent(bin);
353 }
354 
355 ////////////////////////////////////////////////////////////////////////////////
356 /// Create or recreate the histogram.
357 
359 {
360  if (fHistogram) delete fHistogram;
361  fHistogram = NULL;
362  fHistogram = new TH1F("hpa", "hpa", fNbins, fMinCurrent, fMaxCurrent+0.0001*(fMaxCurrent-fMinCurrent));
366  for(Long64_t li=first; li<first+nentries;++li) {
367  if(fVal[li] >= fMinCurrent && fVal[li] <= fMaxCurrent) fHistogram->Fill(fVal[li]);
368  }
369  return fHistogram;
370 }
371 
372 ////////////////////////////////////////////////////////////////////////////////
373 /// Get mean, min and max of those variable.
374 
376 {
377  Double_t min,max,ave = 0;
378  min = DBL_MAX;
379  max = -DBL_MAX;
381  first = fParallel->GetCurrentFirst();
382  nentries = fParallel->GetCurrentN();
383  for(Long64_t li=first; li<first+nentries;++li){
384  if(fVal[li]<min) min = fVal[li];
385  if(fVal[li]>max) max = fVal[li];
386  ave+=fVal[li];
387  }
388 
389  fMean = ave/((Double_t)nentries);
390  fMinCurrent = fMinInit = min;
391  fMaxCurrent = fMaxInit = max;
392 }
393 
394 ////////////////////////////////////////////////////////////////////////////////
395 /// Returns info about this axis.
396 
398 {
399  static char info[128];
400  info[0] = 0;
401 
402  if (!gPad) return info;
403  Double_t xx = gPad->AbsPixeltoX(px);
404  Double_t yy = gPad->AbsPixeltoY(py);
405  if (fX1 == fX2) {
406  if (yy<fY1) {
407  snprintf(info,128,"%s = %f", GetTitle(), fMinCurrent);
408  } else if (yy>fY2) {
409  snprintf(info,128,"%s = %f", GetTitle(), fMaxCurrent);
410  } else {
411  Double_t axislength = fY2-fY1;
412  Double_t pos = (yy-fY1)/axislength;
413  snprintf(info,128,"%s = %f", GetTitle(), fMinCurrent + pos*(fMaxCurrent-fMinCurrent));
414  }
415  } else {
416  if (xx<fX1) {
417  snprintf(info,128,"%s = %f", GetTitle(), fMinCurrent);
418  } else if(xx>fX2) {
419  snprintf(info,128,"%s = %f", GetTitle(), fMaxCurrent);
420  } else {
421  Double_t axislength = fX2-fX1;
422  Double_t pos = (xx-fX1)/axislength;
423  snprintf(info,128,"%s = %f", GetTitle(), pos*(fMaxCurrent-fMinCurrent));
424  }
425  }
426  return info;
427 }
428 
429 ////////////////////////////////////////////////////////////////////////////////
430 /// Get the box plot values (quantiles).
431 
433 {
434  Double_t *quantiles = new Double_t[3];
435  quantiles[0]=0.; quantiles[1]=0.; quantiles[2] = 0.;
436  Double_t *prob = new Double_t[3];
437  prob[0]=0.25; prob[1]=0.5; prob[2] = 0.75;
440  if (!TestBit(kLogScale) && first==0 && nentries==fNentries) TMath::Quantiles(fNentries,3,fVal,quantiles,prob,kFALSE);
441  else {
442  Double_t* val = new Double_t[nentries];
443  Int_t selected = 0;
444  if(fMinInit<=0) {
445  for (Long64_t n=first;n<first+nentries;++n) {
446  if (fVal[n] >= fMinCurrent) {
447  if (TestBit(kLogScale)) val[selected] = TMath::Log10(fVal[n]);
448  else val[selected] = fVal[n];
449  ++selected;
450  }
451  }
452  } else {
453  for (Long64_t n=first;n<first+nentries;++n) {
454  if (TestBit(kLogScale)) val[selected] = TMath::Log10(fVal[n]);
455  else val[selected] = fVal[n];
456  ++selected;
457  }
458  }
459  TMath::Quantiles(selected,3,val,quantiles,prob,kFALSE);
460  delete [] val;
461  }
462  fQua1 = quantiles[0];
463  fMed = quantiles[1];
464  fQua3 = quantiles[2];
465  delete [] quantiles;
466  delete [] prob;
467 }
468 
469 ////////////////////////////////////////////////////////////////////////////////
470 /// Get the value corresponding to the position.
471 
473 {
474  Double_t pos;
475  if (fMinCurrent == fMaxCurrent) return fMinCurrent;
476  if (fX1 == fX2) {
477  if (y<=fY1) pos = fMinCurrent;
478  else if (y>=fY2) pos = fMaxCurrent;
479  else pos = fMinCurrent + ((y-fY1)/(fY2-fY1))*(fMaxCurrent-fMinCurrent);
480  } else {
481  if (x<=fX1) pos = fMinCurrent;
482  else if (x>=fX2) pos = fMaxCurrent;
483  else pos = fMinCurrent + ((x-fX1)/(fX2-fX1))*(fMaxCurrent-fMinCurrent);
484  }
485  return pos;
486 }
487 
488 ////////////////////////////////////////////////////////////////////////////////
489 /// Get a position corresponding to the value on the axis.
490 
492 {
493  if(value < fMinCurrent || value > fMaxCurrent) return;
494 
495  if (fX1==fX2) {
496  x = fX1;
497  if (fMinCurrent != fMaxCurrent) {
498  if (TestBit(kLogScale)) y = fY1 + (fY2 - fY1) *
499  (TMath::Log10(value/fMinCurrent)) / (TMath::Log10(fMaxCurrent/fMinCurrent));
500  else y = fY1 + (fY2 - fY1) *
501  (value - fMinCurrent) / (fMaxCurrent - fMinCurrent);
502  } else {
503  y = fY1 + 0.5*(fY2-fY1);
504  }
505  } else {
506  y = fY1;
507  if (fMinCurrent != fMaxCurrent) {
508  if (TestBit(kLogScale)) x = fX1 + (fX2 - fX1) *
509  (TMath::Log10(value/fMinCurrent)) / (TMath::Log10(fMaxCurrent/fMinCurrent));
510  else x = fX1 + (fX2 - fX1) *
511  (value - fMinCurrent) / (fMaxCurrent - fMinCurrent);
512  } else {
513  x = fX1 + 0.5*(fX2-fX1);
514  }
515  }
516 }
517 
518 ////////////////////////////////////////////////////////////////////////////////
519 /// Initialise the TParallelVar variables.
520 
522 {
523  fX1 = 0;
524  fX2 = 0;
525  fY1 = 0;
526  fY2 = 0;
527  fId = 0;
528  fVal = NULL;
529  fMean = 0;
530  fMinInit = 0;
531  fMinCurrent = 0;
532  fMaxInit = 0;
533  fMaxCurrent = 0;
534  fMed = 0;
535  fQua1 = 0;
536  fQua3 = 0;
537  fNentries = 0;
538  fParallel = NULL;
539  fHistogram = NULL;
540  fNbins = 100;
541  fHistoLW = 2;
542  fHistoHeight = 0.5;
543  fRanges = NULL;
547 }
548 
549 ////////////////////////////////////////////////////////////////////////////////
550 /// Paint the axis.
551 
553 {
554  PaintHistogram();
555  if (TestBit(kShowBox)) PaintBoxPlot();
556  PaintLabels();
557 }
558 
559 ////////////////////////////////////////////////////////////////////////////////
560 /// Paint the boxes in the case of a candle chart.
561 
563 {
564  TLine *line = new TLine();
565  line->SetLineColor(GetLineColor());
566  line->SetLineWidth(1);
567  TBox *box = new TBox();
568  box->SetLineWidth(1);
569  box->SetLineColor(GetLineColor());
570  box->SetLineStyle(1);
571  box->SetFillStyle(0);
572 
573  TFrame* frame = gPad->GetFrame();
574 
575  Double_t boxSize;
576  if (fParallel->GetNvar() > 1) {
577  if (fX1==fX2) boxSize = fHistoHeight*((frame->GetY2()-frame->GetY1())/(fParallel->GetNvar()-1));
578  else boxSize = fHistoHeight*((frame->GetX2()-frame->GetX1())/(fParallel->GetNvar()-1));
579  if (boxSize >= 0.03) boxSize = 0.03;
580  }
581  else boxSize = 0.03;
582 
583  Double_t qua1,med,qua3,max,min;
584  Double_t a,b,maxinit,mininit;
585  if (TestBit(kLogScale)) {
588  if(fMinInit > 0) mininit = TMath::Log10(fMinInit);
589  else mininit = TMath::Log10(fMinCurrent);
590  maxinit = TMath::Log10(fMaxInit);
591  } else {
592  a = fMinCurrent;
594  mininit = fMinInit;
595  maxinit = fMaxInit;
596  }
597  if(fX1==fX2) {
598  qua1 = fY1 + ((fQua1-a)/b)*(fY2-fY1);
599  qua3 = fY1 + ((fQua3-a)/b)*(fY2-fY1);
600  med = fY1 + ((fMed-a)/b)*(fY2-fY1);
601  max = fY1 + ((maxinit-a)/b)*(fY2-fY1);
602  min = fY1 + ((mininit-a)/b)*(fY2-fY1);
603  } else {
604  qua1 = fX1 + ((fQua1-a)/b)*(fX2-fX1);
605  qua3 = fX1 + ((fQua3-a)/b)*(fX2-fX1);
606  med = fX1 + ((fMed-a)/b)*(fX2-fX1);
607  max = fX1 + ((maxinit-a)/b)*(fX2-fX1);
608  min = fX1 + ((mininit-a)/b)*(fX2-fX1);
609  }
610 
611  // min and max lines.
612  if (fX1==fX2) {
613  line->PaintLine(fX1-boxSize,min,fX1+boxSize,min);
614  line->PaintLine(fX2-boxSize,max,fX2+boxSize,max);
615  } else {
616  line->PaintLine(min,fY1-boxSize,min,fY1+boxSize);
617  line->PaintLine(max,fY2-boxSize,max,fY2+boxSize);
618  }
619 
620  // lines from min and max to the box.
621  line->SetLineStyle(7);
622  if (fX1==fX2) {
623  if (min<frame->GetY1()) min = frame->GetY1();
624  if (max>frame->GetY2()) max = frame->GetY2();
625  line->PaintLine(fX1,min,fX1,qua1);
626  line->PaintLine(fX1,qua3,fX1,max);
627  } else {
628  if (min<frame->GetX1()) min = frame->GetX1();
629  if (max>frame->GetX2()) max = frame->GetX2();
630  line->PaintLine(min,fY1,qua1,fY2);
631  line->PaintLine(qua3,fY1,max,fY2);
632  }
633 
634  // Box
635  if(fX1==fX2) box->PaintBox(fX1-boxSize,qua1,fX1+boxSize,qua3);
636  else box->PaintBox(qua1,fY1-boxSize,qua3,fY1+boxSize);
637 
638  // Median line
639  line->SetLineStyle(1);
640  if(fX1==fX2) line->PaintLine(fX1-boxSize,med,fX1+boxSize,med);
641  else line->PaintLine(med,fY1-boxSize,med,fY1+boxSize);
642 
643  // Paint average
644  if (!TestBit(kLogScale) || (TestBit(kLogScale) && fMean > 0)) {
645  Double_t mean;
646  if (TestBit(kLogScale)) mean = TMath::Log10(fMean);
647  else mean = fMean;
648  TMarker *mark = NULL;
649  if(fX1==fX2) mark = new TMarker(fX1,fY1 + ((mean-a)/b)*(fY2-fY1),24);
650  else mark = new TMarker(fX1 + ((mean-a)/b)*(fX2-fX1),fY1,24);
651  mark->Paint();
652  delete mark;
653  }
654 
655  delete line;
656  delete box;
657 }
658 
659 ////////////////////////////////////////////////////////////////////////////////
660 /// Paint the histogram on the axis.
661 
663 {
664  Int_t i;
665 
666  TFrame *frame = gPad->GetFrame();
667 
668  if (!fHistogram) GetHistogram();
669 
670  // Paint the axis body.
671  if (fHistoHeight!=0 && TestBit(kShowBarHisto)) {
672  // Paint the axis body using bar chart.
673  TBox *b = new TBox();
676  b->SetLineStyle(1);
678  b->SetLineWidth(1);
679  Double_t hmin = fHistogram->GetMinimum();
680  Double_t hmax = fHistogram->GetMaximum();
681  if (fX1 == fX2) {
682  // Vertical case.
683  Double_t dy = (fY2-fY1)/fNbins;
686  Double_t y1 = fY1,x2,y2;
687  for (i=1; i<=fNbins; i++) {
688  x2 = fX1+((fHistogram->GetBinContent(i)-hmin)/(hmax-hmin))*fHistoHeight*
689  ((frame->GetX2()-frame->GetX1())/(fParallel->GetNvar()-1));
691  else y2=y1+dy;
692  b->PaintBox(fX1,y1,x2,y2,"l");
693  y1=y2;
694  v += dv;
695  }
696  } else {
697  // Horizontal case.
698  Double_t dx = (fX2-fX1)/fNbins;
701  Double_t x1 = fX1,x2,y2;
702  for (i=1; i<=fNbins; i++) {
703  y2 = fY1+((fHistogram->GetBinContent(i)-hmin)/(hmax-hmin))*fHistoHeight*((frame->GetY2()-frame->GetY1())/(fParallel->GetNvar()-1));
705  else x2=x1+dx;
706  b->PaintBox(x1,fY1,x2,y2,"l");
707  x1=x2;
708  v+=dv;
709  }
710  }
711  delete b;
712  }
713  if (fHistoLW==0 && !TestBit(kShowBox)) {
714  // Paint the axis body as a simple line.
715  TLine* l = new TLine(fX1,fY1,fX2,fY2);
719  l->Paint();
720  delete l;
721  } else if (fHistoLW!=0){
722  // Paint the axis body using the color palette.
723  TLine *lb = new TLine();
724  lb->SetLineWidth(fHistoLW);
725  Double_t hmin = fHistogram->GetMinimum();
726  Double_t hmax = fHistogram->GetMaximum();
727  Int_t theColor;
728  Int_t ncolors = gStyle->GetNumberOfColors();
729  if (fX1 == fX2) {
730  // Vertical case.
731  Double_t dy = (fY2-fY1)/fNbins;
732  Double_t y1 = fY1,y2;
735  for (i=1; i<=fNbins; i++) {
736  theColor = (Int_t)( ((fHistogram->GetBinContent(i)-hmin)/(hmax-hmin))*(ncolors-1) );
738  else y2=y1+dy;
739  lb->SetLineColor(gStyle->GetColorPalette(theColor));
740  lb->PaintLine(fX1,y1,fX1,y2);
741  y1=y2;
742  v+=dv;
743  }
744  } else {
745  // Horizontal case.
746  Double_t dx = (fX2-fX1)/fNbins;
749  Double_t x1 = fX1,x2;
750  for (i=1; i<=fNbins; i++) {
751  theColor = (Int_t)( ((fHistogram->GetBinContent(i)-hmin)/(hmax-hmin))*(ncolors-1) );
752  lb->SetLineColor(gStyle->GetColorPalette(theColor));
754  else x2=x1+dx;
755  lb->PaintLine(x1,fY1,x2,fY1);
756  x1=x2;
757  v+=dv;
758  }
759  }
760  delete lb;
761  }
762 }
763 
764 ////////////////////////////////////////////////////////////////////////////////
765 /// Paint the axis labels and titles.
766 
768 {
769  TLatex* t = new TLatex();
770  TFrame *frame = gPad->GetFrame();
771  t->SetTextSize(0.03);
772  if (fX1==fX2) {
773  t->SetText(fX1,frame->GetY1() - 0.04 - t->GetTextSize(),GetName());
774  Double_t tlength = t->GetXsize();
775  if (fX1-0.5*tlength<0.01) {
776  t->SetTextAlign(11);
777  t->SetText(0.01, frame->GetY1() - 0.04 - t->GetTextSize(), GetName());
778  t->Paint();
779  } else if (fX1+0.5*tlength > 0.99) {
780  t->SetTextAlign(31);
781  t->SetText(0.99,frame->GetY1() - 0.04 - t->GetTextSize(),GetName());
782  t->Paint();
783  } else {
784  t->SetTextAlign(21);
785  t->PaintLatex(fX1,frame->GetY1() - 0.04 - t->GetTextSize(),0,0.03,GetName());
786  }
788  t->SetTextAlign(21);
789  t->PaintLatex(fX1,frame->GetY2() + 0.005,0,0.025,Form("%g",fMaxCurrent));
790  t->SetTextAlign(23);
791  t->PaintLatex(fX1,frame->GetY1() - 0.005,0,0.025,Form("%g",fMinCurrent));
792  }
793  } else {
794  t->SetText(fX1-0.04,fY1+0.02,GetName());
795  t->SetTextSize(0.03);
796  Double_t tlength = t->GetXsize();
797  if (fX1-0.04-tlength<0.01) {
798  t->SetTextAlign(12);
799  t->SetText(0.01,fY1+0.02,GetName());
800  t->Paint();
801  } else {
802  t->SetTextAlign(32);
803  t->PaintLatex(fX1-0.04,fY1+0.02,0,0.03,GetName());
804  }
806  t->SetTextAlign(12);
807  t->PaintLatex(0.01,fY1-0.02,0,0.025,Form("%g",fMinCurrent));
808  t->SetTextAlign(32);
809  t->PaintLatex(0.99,fY1-0.02,0,0.025,Form("%g",fMaxCurrent));
810  }
811  }
812  delete t;
813 }
814 
815 ////////////////////////////////////////////////////////////////////////////////
816 /// Print the axis main data.
817 
818 void TParallelCoordVar::Print(Option_t* /*option*/) const
819 {
820  printf("**************variable #%d**************\n",fParallel->GetVarList()->IndexOf(this));
821  printf("at x1=%f, y1=%f, x2=%f, y2=%f.\n",fX1,fY1,fX2,fY2);
822  printf("min = %f, Q1 = %f, Med = %f, Q3 = %f, Max = %f\n", fMinInit, fQua1, fMed, fQua3, fMaxInit);
823 }
824 
825 ////////////////////////////////////////////////////////////////////////////////
826 /// Save the TParallelCoordVar as a macro. Can be used only in the context
827 /// of TParallelCoord::SavePrimitive (pointer "TParallelCoord* para" is
828 /// defined in TParallelCoord::SavePrimitive) with the option "pcalled".
829 
830 void TParallelCoordVar::SavePrimitive(std::ostream & out, Option_t* options)
831 {
832  TString opt = options;
833  if (opt.Contains("pcalled")) {
834  out<<" var->SetBit(TParallelCoordVar::kLogScale,"<<TestBit(kLogScale)<<");"<<std::endl;
835  out<<" var->SetBit(TParallelCoordVar::kShowBox,"<<TestBit(kShowBox)<<");"<<std::endl;
836  out<<" var->SetBit(TParallelCoordVar::kShowBarHisto,"<<TestBit(kShowBarHisto)<<");"<<std::endl;
837  out<<" var->SetHistogramBinning("<<fNbins<<");"<<std::endl;
838  out<<" var->SetHistogramLineWidth("<<fHistoLW<<");"<<std::endl;
839  out<<" var->SetInitMin("<<fMinInit<<");"<<std::endl;
840  out<<" var->SetInitMax("<<fMaxInit<<");"<<std::endl;
841  out<<" var->SetHistogramHeight("<<fHistoHeight<<");"<<std::endl;
842  out<<" var->GetMinMaxMean();"<<std::endl;
843  out<<" var->GetHistogram();"<<std::endl;
844  out<<" var->SetFillStyle("<<GetFillStyle()<<");"<<std::endl;
845  out<<" var->SetFillColor("<<GetFillColor()<<");"<<std::endl;
846  out<<" var->SetLineColor("<<GetLineColor()<<");"<<std::endl;
847  out<<" var->SetLineWidth("<<GetLineWidth()<<");"<<std::endl;
848  out<<" var->SetLineStyle("<<GetLineStyle()<<");"<<std::endl;
849  if (TestBit(kShowBox)) out<<" var->GetQuantiles();"<<std::endl;
850  TIter next(fRanges);
851  TParallelCoordRange* range;
852  Int_t i = 1;
853  while ((range = (TParallelCoordRange*)next())) {
854  out<<" //***************************************"<<std::endl;
855  out<<" // Create the "<<i<<"th range owned by the axis \""<<GetTitle()<<"\"."<<std::endl;
856  out<<" TParallelCoordSelect* sel = para->GetSelection(\""<<range->GetSelection()->GetTitle()<<"\");"<<std::endl;
857  out<<" TParallelCoordRange* newrange = new TParallelCoordRange(var,"<<range->GetMin()<<","<<range->GetMax()<<",sel);"<<std::endl;
858  out<<" var->AddRange(newrange);"<<std::endl;
859  out<<" sel->Add(newrange);"<<std::endl;
860  ++i;
861  }
862  }
863 }
864 
865 ////////////////////////////////////////////////////////////////////////////////
866 /// Set the axis to display a candle.
867 
869 {
870  SetBit(kShowBox,box);
871  if (box) SetHistogramHeight(0.5);
872  else {
875  }
876 }
877 
878 ////////////////////////////////////////////////////////////////////////////////
879 /// Set the histogram binning.
880 
882 {
883  if (n < 0 || n == fNbins) return;
884  fNbins = n;
885  GetHistogram();
886 }
887 
888 ////////////////////////////////////////////////////////////////////////////////
889 /// Set the height of the bar histogram.
890 
892 {
893  fHistoHeight = h;
895  if(h!=0) SetBit(kShowBarHisto,kTRUE);
897  }
898 }
899 
900 ////////////////////////////////////////////////////////////////////////////////
901 /// Set the current minimum of the axis.
902 
904 {
905  fMinCurrent = min;
906 }
907 
908 ////////////////////////////////////////////////////////////////////////////////
909 /// Set the current maximum of the axis.
910 
912 {
913  fMaxCurrent = max;
914 }
915 
916 ////////////////////////////////////////////////////////////////////////////////
917 /// Set the limits within which one the entries must be painted.
918 
920 {
921  if (min>max) {
922  Double_t mem = min;
923  min = max;
924  max = mem;
925  }
926  if(TestBit(kLogScale) && max<=0) return;
927  if(TestBit(kLogScale) && min<=0) min = 0.00001*max;
928  fMinCurrent = min;
929  fMaxCurrent = max;
930 
931  delete fHistogram;
932  fHistogram = NULL;
933  GetHistogram();
934 
936  fParallel->SetGlobalMin(min);
937  fParallel->SetGlobalMax(max);
938  }
939 }
940 
941 ////////////////////////////////////////////////////////////////////////////////
942 /// If true, the pad is updated while the motion of a dragged range.
943 
945 {
946  TIter next(fRanges);
947  TParallelCoordRange* range;
948  while ((range = (TParallelCoordRange*)next())) range->SetBit(TParallelCoordRange::kLiveUpdate,on);
949 }
950 
951 ////////////////////////////////////////////////////////////////////////////////
952 /// Set the axis in log scale.
953 
955 {
956  if (log == TestBit (kLogScale)) return;
957  if (fMaxInit < 0) SetBit(kLogScale,kFALSE);
958  else if (log) {
959  if (fMaxCurrent < 0 ) fMaxCurrent = fMaxInit;
960  if (fMinCurrent < 0 ) fMinCurrent = 0.00001*fMaxCurrent;
964  } else {
968  }
969  GetQuantiles();
970  GetHistogram();
971 }
972 
973 ////////////////////////////////////////////////////////////////////////////////
974 /// Set the variable values.
975 
977 {
978  if (fVal) delete [] fVal;
979  fVal = new Double_t[length];
980  fNentries = length;
981  for (Long64_t li = 0; li < length; ++li) fVal[li] = val[li];
982  GetMinMaxMean();
983  GetHistogram();
984  if (TestBit(kShowBox)) GetQuantiles();
985 }
986 
987 ////////////////////////////////////////////////////////////////////////////////
988 /// Set the X position of the axis in the case of a vertical axis.
989 /// and rotate the axis if it was horizontal.
990 
992 {
993  TFrame *frame = gPad->GetFrame();
994  if (!gl) {
995  fY1 = frame->GetY1();
996  fY2 = frame->GetY2();
997  } else {
998  Double_t gmin = fParallel->GetGlobalMin();
999  Double_t gmax = fParallel->GetGlobalMax();
1000  fY1 = frame->GetY1() + ((fMinCurrent-gmin)/(gmax-gmin))*(frame->GetY2()-frame->GetY1());
1001  fY2 = frame->GetY1() + ((fMaxCurrent-gmin)/(gmax-gmin))*(frame->GetY2()-frame->GetY1());
1002  }
1003  fX1 = fX2 = x;
1004 }
1005 
1006 ////////////////////////////////////////////////////////////////////////////////
1007 /// Set the Y position of the axis in the case of a horizontal axis.
1008 /// and rotate the axis if it was vertical.
1009 
1011 {
1012  TFrame *frame = gPad->GetFrame();
1013  if (!gl) {
1014  fX1 = frame->GetX1();
1015  fX2 = frame->GetX2();
1016  } else {
1017  Double_t gmin = fParallel->GetGlobalMin();
1018  Double_t gmax = fParallel->GetGlobalMax();
1019  fX1 = frame->GetX1() + ((fMinCurrent-gmin)/(gmax-gmin))*(frame->GetX2()-frame->GetX1());
1020  fX2 = frame->GetX1() + ((fMaxCurrent-gmin)/(gmax-gmin))*(frame->GetX2()-frame->GetX1());
1021  }
1022  fY1 = fY2 = y;
1023 }
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
Definition: TAttLine.h:43
virtual void AddAt(TObject *obj, Int_t idx)
Insert object at position idx in the list.
Definition: TList.cxx:273
virtual Int_t Fill(Double_t x)
Increment bin with abscissa X by 1.
Definition: TH1.cxx:3126
A TParallelCoordSelect is a specialised TList to hold TParallelCoordRanges used by TParallelCoord...
double dist(Rotation3D const &r1, Rotation3D const &r2)
Definition: 3DDistances.cxx:48
virtual Double_t GetMaximum(Double_t maxval=FLT_MAX) const
Return maximum value smaller than maxval of bins in the range, unless the value has been overridden b...
Definition: TH1.cxx:7666
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:409
void CleanUpSelections(TParallelCoordRange *range)
Clean up the selections from the ranges which could have been deleted when a variable has been delete...
virtual void ExecuteEvent(Int_t entry, Int_t px, Int_t py)
Execute the corresponding entry.
long long Long64_t
Definition: RtypesCore.h:69
TParallelCoordSelect * GetCurrentSelection()
Return the selection currently being edited.
void SetCurrentMax(Double_t max)
Set the current maximum of the axis.
Double_t GetX2() const
Definition: TBox.h:53
TLine * line
virtual void Draw(Option_t *options="")
Draw a TParallelCoordRange.
virtual void SetDirectory(TDirectory *dir)
By default when an histogram is created, it is added to the list of histogram objects in the current ...
Definition: TH1.cxx:8053
const char Option_t
Definition: RtypesCore.h:62
void PaintBoxPlot()
Paint the boxes in the case of a candle chart.
Create a Box.
Definition: TBox.h:24
Double_t GetValuefromXY(Double_t x, Double_t y)
Get the value corresponding to the position.
R__EXTERN TStyle * gStyle
Definition: TStyle.h:402
#define mark(osub)
Definition: triangle.c:1206
Bool_t TestBit(UInt_t f) const
Definition: TObject.h:159
THist< 1, float, THistStatContent, THistStatUncertainty > TH1F
Definition: THist.hxx:311
TH1 * h
Definition: legend2.C:5
void SetLogScale(Bool_t log)
Set the axis in log scale.
virtual Double_t GetBinContent(Int_t bin) const
Return content of bin number bin.
Definition: TH1.cxx:4639
void SetCurrentMin(Double_t min)
Set the current minimum of the axis.
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
Computes the distance from the axis.
Basic string class.
Definition: TString.h:129
tomato 1-D histogram with a float per channel (see TH1 documentation)}
Definition: TH1.h:551
Manages Markers.
Definition: TMarker.h:23
A TParallelCoordRange is a range used for parallel coordinates plots.
void SetValues(Long64_t length, Double_t *val)
Set the variable values.
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
Double_t GetY2() const
Definition: TBox.h:55
TArc * a
Definition: textangle.C:12
virtual void SetFillStyle(Style_t fstyle)
Set the fill area style.
Definition: TAttFill.h:39
TH1F * GetHistogram()
Create or recreate the histogram.
void GetXYfromValue(Double_t value, Double_t &x, Double_t &y)
Get a position corresponding to the value on the axis.
#define NULL
Definition: RtypesCore.h:88
Bool_t Contains(const char *name) const
Definition: TCollection.h:78
void SetBoxPlot(Bool_t box)
Set the axis to display a candle.
void box(Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Definition: fillpatterns.C:1
~TParallelCoordVar()
Destructor.
Short_t Abs(Short_t d)
Definition: TMathBase.h:108
virtual Width_t GetLineWidth() const
Return the line width.
Definition: TAttLine.h:35
Double_t GetGlobalMin()
return the global minimum.
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:687
TParallelCoordSelect * GetSelection()
void GetEntryXY(Long64_t n, Double_t &x, Double_t &y)
Get the position of the variable on the graph for the n&#39;th entry.
virtual void AppendPad(Option_t *option="")
Append graphics object to current pad.
Definition: TObject.cxx:112
TParallelCoord axes.
TParallelCoordVar()
Histogram holding the variable distribution.
virtual Style_t GetLineStyle() const
Return the line style.
Definition: TAttLine.h:34
void SetX(Double_t x, Bool_t gl)
Set the X position of the axis in the case of a vertical axis.
static const double x2[5]
Fill Area Attributes class.
Definition: TAttFill.h:19
Double_t x[n]
Definition: legend1.C:17
virtual void SetText(Double_t x, Double_t y, const char *text)
Definition: TText.h:72
TList * GetVarList()
void SetY(Double_t y, Bool_t gl)
Set the Y position of the axis in the case of a horizontal axis.
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
virtual Float_t GetTextSize() const
Return the text size.
Definition: TAttText.h:36
void Quantiles(Int_t n, Int_t nprob, Double_t *x, Double_t *quantiles, Double_t *prob, Bool_t isSorted=kTRUE, Int_t *index=0, Int_t type=7)
Computes sample quantiles, corresponding to the given probabilities Parameters: x -the data sample n ...
Definition: TMath.cxx:1177
void SetCurrentLimits(Double_t min, Double_t max)
Set the limits within which one the entries must be painted.
To draw Mathematical Formula.
Definition: TLatex.h:18
void DeleteVariable()
Delete variables.
Double_t Log10(Double_t x)
Definition: TMath.h:652
virtual void Paint(Option_t *option="")
Paint.
Definition: TLatex.cxx:2021
virtual void Paint(Option_t *option="")
Paint this line with its current attributes.
Definition: TLine.cxx:371
void SetLiveRangesUpdate(Bool_t on)
If true, the pad is updated while the motion of a dragged range.
void GetMinMaxMean()
Get mean, min and max of those variable.
virtual char * GetObjectInfo(Int_t px, Int_t py) const
Returns info about this axis.
Int_t GetColorPalette(Int_t i) const
Return color number i in current palette.
Definition: TStyle.cxx:735
void PaintHistogram()
Paint the histogram on the axis.
virtual Double_t GetMax()
virtual void PaintLatex(Double_t x, Double_t y, Double_t angle, Double_t size, const char *text)
Main drawing function.
Definition: TLatex.cxx:2042
Long64_t GetCurrentN()
Int_t GetEntryWeight(Long64_t evtidx)
Get the entry weight: The weight of an entry for a given variable is the bin content of the histogram...
void SetGlobalMax(Double_t max)
Force all variables to adopt the same max.
virtual void SetTextAlign(Short_t align=11)
Set the text alignment.
Definition: TAttText.h:41
void PaintLabels()
Paint the axis labels and titles.
A doubly linked list.
Definition: TList.h:43
virtual void PaintLine(Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Draw this line with new coordinates.
Definition: TLine.cxx:380
virtual void Paint(Option_t *option="")
Paint this marker with its current attributes.
Definition: TMarker.cxx:251
void RemoveVariable(TParallelCoordVar *var)
Delete a variable from the graph.
Long64_t GetCurrentFirst()
virtual void Paint(Option_t *option="")
Paint the axis.
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition: TAttLine.h:40
TParallelCoord * fParallel
Double_t GetGlobalMax()
return the global maximum.
Double_t GetXsize()
Return size of the formula along X in pad coordinates.
Definition: TLatex.cxx:2514
SVector< double, 2 > v
Definition: Dict.h:5
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition: TAttFill.h:37
virtual TObject * Remove(TObject *obj)
Remove object from the list.
Definition: TList.cxx:679
void SetHistogramBinning(Int_t n=100)
Set the histogram binning.
unsigned int UInt_t
Definition: RtypesCore.h:42
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:873
char * Form(const char *fmt,...)
A simple line.
Definition: TLine.h:23
TLine * l
Definition: textangle.C:4
void SetGlobalMin(Double_t min)
Force all variables to adopt the same min.
const char * GetTitle() const
Returns title of object.
Int_t GetNumberOfColors() const
Return number of colors in the color palette.
Definition: TStyle.cxx:801
virtual void PaintBox(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Option_t *option="")
Draw this box with new coordinates.
Definition: TBox.cxx:627
Long64_t GetNentries()
#define gVirtualX
Definition: TVirtualX.h:350
Define a Frame.
Definition: TFrame.h:19
void Init()
Initialise the TParallelVar variables.
virtual Double_t GetMinimum(Double_t minval=-FLT_MAX) const
Return minimum value larger than minval of bins in the range, unless the value has been overridden by...
Definition: TH1.cxx:7751
const Bool_t kFALSE
Definition: RtypesCore.h:92
virtual Color_t GetLineColor() const
Return the line color.
Definition: TAttLine.h:33
void GetQuantiles()
Get the box plot values (quantiles).
The Canvas class.
Definition: TCanvas.h:31
void SetHistogramHeight(Double_t h=0)
Set the height of the bar histogram.
static const double x1[5]
#define ClassImp(name)
Definition: Rtypes.h:336
Double_t GetX1() const
Definition: TBox.h:52
virtual void Draw(Option_t *option="")
Draw the axis.
double Double_t
Definition: RtypesCore.h:55
void SavePrimitive(std::ostream &out, Option_t *options)
Save the TParallelCoordVar as a macro.
virtual void Print(Option_t *option="") const
Print the axis main data.
int nentries
Definition: THbookFile.cxx:89
Double_t y[n]
Definition: legend1.C:17
virtual Color_t GetFillColor() const
Return the fill area color.
Definition: TAttFill.h:30
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:572
Bool_t IsIn(Double_t evtval)
Evaluate if the given value is within the range or not.
virtual void SetLineStyle(Style_t lstyle)
Set the line style.
Definition: TAttLine.h:42
Parallel Coordinates class.
void SetHistogramLineWidth(Int_t lw=2)
UInt_t GetNvar()
virtual void Add(TObject *obj)
Definition: TList.h:77
TList * fRanges
[fNentries] Entries values for the variable.
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
#define snprintf
Definition: civetweb.c:822
#define gPad
Definition: TVirtualPad.h:284
Double_t GetY1() const
Definition: TBox.h:54
virtual Double_t GetMin()
Definition: first.py:1
virtual Style_t GetFillStyle() const
Return the fill area style.
Definition: TAttFill.h:31
virtual void SetTextSize(Float_t tsize=1)
Set the text size.
Definition: TAttText.h:46
virtual Int_t GetSize() const
Definition: TCollection.h:89
const Bool_t kTRUE
Definition: RtypesCore.h:91
const Int_t n
Definition: legend1.C:16
Line Attributes class.
Definition: TAttLine.h:18
Bool_t Eval(Long64_t evtidx, TParallelCoordSelect *select)
Check if the entry is within the range(s) of "select".
double log(double)
Definition: Rtypes.h:57
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
virtual Int_t IndexOf(const TObject *obj) const
Return index of object in collection.