Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TPie.cxx
Go to the documentation of this file.
1// @(#)root/graf:$Id$
2// Author: Guido Volpi, Olivier Couet 03/11/2006
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, 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 "TPie.h"
13#include "TPieSlice.h"
14
15#include "TROOT.h"
16#include "TVirtualPad.h"
17#include "TVirtualX.h"
18#include "TArc.h"
19#include "TLegend.h"
20#include "TMath.h"
21#include "TStyle.h"
22#include "TLatex.h"
23#include "TPaveText.h"
24#include "TH1.h"
25#include "TColor.h"
26#include "TLine.h"
27
28#include <iostream>
29
31
32/** \class TPie
33\ingroup BasicGraphics
34
35Draw a Pie Chart,
36
37Example:
38
39Begin_Macro(source)
40../../../tutorials/graphics/piechart.C
41End_Macro
42*/
43
44Double_t gX = 0; // Temporary pie X position.
45Double_t gY = 0; // Temporary pie Y position.
46Double_t gRadius = 0; // Temporary pie Radius of the TPie.
47Double_t gRadiusOffset = 0; // Temporary slice's radial offset.
48Double_t gAngularOffset = 0; // Temporary slice's angular offset.
49Bool_t gIsUptSlice = kFALSE; // True if a slice in the TPie should
50 // be updated.
51Int_t gCurrent_slice = -1;// Current slice under mouse.
52Double_t gCurrent_phi1 = 0; // Phimin of the current slice.
53Double_t gCurrent_phi2 = 0; // Phimax of the current slice.
54Double_t gCurrent_rad = 0; // Current distance from the vertex of the
55 // current slice.
56Double_t gCurrent_x = 0; // Current x in the pad metric.
57Double_t gCurrent_y = 0; // Current y in the pad metric.
58Double_t gCurrent_ang = 0; // Current angular, within current_phi1
59 // and current_phi2.
60
61////////////////////////////////////////////////////////////////////////////////
62/// Default constructor.
63
65{
66 Init(1, 0, 0.5, 0.5, 0.4);
67}
68
69////////////////////////////////////////////////////////////////////////////////
70/// This constructor creates a pie chart when only the number of
71/// the slices is known. The number of slices is fixed.
72
73TPie::TPie(const char *name, const char *title, Int_t npoints) :
74 TNamed(name,title)
75{
76 Init(npoints, 0, 0.5, 0.5, 0.4);
77}
78
79////////////////////////////////////////////////////////////////////////////////
80/// Normal constructor. The 1st and 2nd parameters are the name of the object
81/// and its title.
82///
83/// The number of points passed at this point is used to allocate the memory.
84///
85/// Slices values are given as Double_t.
86///
87/// The 4th elements is an array containing, in double precision format,
88/// the value of each slice. It is also possible to specify the filled color
89/// of each slice. If the color array is not specified the slices are colored
90/// using a color sequence in the standard palette.
91
92TPie::TPie(const char *name, const char *title,
93 Int_t npoints, Double_t *vals,
94 Int_t *colors, const char *lbls[]) : TNamed(name,title)
95{
96 Init(npoints, 0, 0.5, 0.5, 0.4);
97 for (Int_t i=0; i<fNvals; ++i) fPieSlices[i]->SetValue(vals[i]);
98
100 SetLabels(lbls);
101}
102
103////////////////////////////////////////////////////////////////////////////////
104/// Normal constructor (Float_t).
105
106TPie::TPie(const char *name,
107 const char *title,
108 Int_t npoints, Float_t *vals,
109 Int_t *colors, const char *lbls[]) : TNamed(name,title)
110{
111 Init(npoints, 0, 0.5, 0.5, 0.4);
112 for (Int_t i=0; i<fNvals; ++i) fPieSlices[i]->SetValue(vals[i]);
113
115 SetLabels(lbls);
116}
117
118////////////////////////////////////////////////////////////////////////////////
119/// Constructor from a TH1
120
121TPie::TPie(const TH1 *h) : TNamed(h->GetName(),h->GetTitle())
122{
123 Int_t i;
124
125 const TAxis *axis = h->GetXaxis();
126 Int_t first = axis->GetFirst();
127 Int_t last = axis->GetLast();
128 Int_t np = last-first+1;
129 Init(np, 0, 0.5, 0.5, 0.4);
130
131 for (i=first; i<=last; ++i) fPieSlices[i-first]->SetValue(h->GetBinContent(i));
132 if (axis->GetLabels()) {
133 for (i=first; i<=last; ++i) fPieSlices[i-first]->SetTitle(axis->GetBinLabel(i));
134 } else {
135 SetLabelFormat("%val");
136 }
137 SetTextSize(axis->GetLabelSize());
139 SetTextFont(axis->GetLabelFont());
140}
141
142////////////////////////////////////////////////////////////////////////////////
143/// Copy constructor.
144
145TPie::TPie(const TPie &cpy) : TNamed(cpy), TAttText(cpy)
146{
147 Init(cpy.fNvals, cpy.fAngularOffset, cpy.fX, cpy.fY, cpy.fRadius);
148
149 for (Int_t i=0;i<fNvals;++i)
150 cpy.fPieSlices[i]->Copy(*fPieSlices[i]);
151}
152
153////////////////////////////////////////////////////////////////////////////////
154/// Destructor.
155
157{
158 if (fNvals>0) {
159 for (int i=0; i<fNvals; ++i) delete fPieSlices[i];
160 delete [] fPieSlices;
161 }
162
163 if (fSlices) delete [] fSlices;
164 if (fLegend) delete fLegend;
165}
166
167////////////////////////////////////////////////////////////////////////////////
168/// Evaluate the distance to the chart in gPad.
169
171{
172 Int_t dist = 9999;
173
175 if ( gCurrent_slice>=0 ) {
176 if (gCurrent_rad<=fRadius) {
177 dist = 0;
178 }
179 }
180
181 return dist;
182}
183
184////////////////////////////////////////////////////////////////////////////////
185/// Returns the slice number at the pixel position (px,py).
186/// Returns -1 if no slice is picked.
187///
188/// Used by DistancetoPrimitive.
189
191{
192 if (!gPad) return 9999;
193 MakeSlices();
194
195 Int_t result(-1);
196
197 // coordinates
198 Double_t xx = gPad->AbsPixeltoX(px); //gPad->PadtoX(gPad->AbsPixeltoX(px));
199 Double_t yy = gPad->AbsPixeltoY(py); //gPad->PadtoY(gPad->AbsPixeltoY(py));
200
201 // XY metric
202 Double_t radX = fRadius;
203 Double_t radY = fRadius;
204 Double_t radXY = 1.;
205 if (fIs3D) {
206 radXY = TMath::Sin(fAngle3D/180.*TMath::Pi());
207 radY = radXY*radX;
208 }
209
210 Double_t phimin;
211 Double_t cphi;
212 Double_t phimax;
213
214 Float_t dPxl = (gPad->PixeltoY(0)-gPad->PixeltoY(1))/radY;
215 for (Int_t i=0;i<fNvals;++i) {
217
218 if (gIsUptSlice && gCurrent_slice!=i) continue;
219
220 // Angles' values for this slice
221 phimin = fSlices[2*i ]*TMath::Pi()/180.;
222 cphi = fSlices[2*i+1]*TMath::Pi()/180.;
223 phimax = fSlices[2*i+2]*TMath::Pi()/180.;
224
225 Double_t radOffset = fPieSlices[i]->GetRadiusOffset();
226
227 Double_t dx = (xx-fX-radOffset*TMath::Cos(cphi))/radX;
228 Double_t dy = (yy-fY-radOffset*TMath::Sin(cphi)*radXY)/radY;
229
230 if (TMath::Abs(dy)<dPxl) dy = dPxl;
231
232 Double_t ang = TMath::ATan2(dy,dx);
233 if (ang<0) ang += TMath::TwoPi();
234
235 Double_t dist = TMath::Sqrt(dx*dx+dy*dy);
236
237 if ( ((ang>=phimin && ang <= phimax) || (phimax>TMath::TwoPi() &&
238 ang+TMath::TwoPi()>=phimin && ang+TMath::TwoPi()<phimax)) &&
239 dist<=1.) { // if true the pointer is in the slice region
240
241 gCurrent_x = dx;
242 gCurrent_y = dy;
243 gCurrent_ang = ang;
244 gCurrent_phi1 = phimin;
245 gCurrent_phi2 = phimax;
246 gCurrent_rad = dist*fRadius;
247
248 if (dist<.95 && dist>.65) {
249 Double_t range = phimax-phimin;
250 Double_t lang = ang-phimin;
251 Double_t rang = phimax-ang;
252 if (lang<0) lang += TMath::TwoPi();
253 else if (lang>=TMath::TwoPi()) lang -= TMath::TwoPi();
254 if (rang<0) rang += TMath::TwoPi();
255 else if (rang>=TMath::TwoPi()) rang -= TMath::TwoPi();
256
257 if (lang/range<.25 || rang/range<.25) {
259 result = -1;
260 }
261 else result = i;
262 } else {
263 result = i;
264 }
265
266 break;
267 }
268 }
269 return result;
270}
271
272////////////////////////////////////////////////////////////////////////////////
273/// Draw the pie chart.
274///
275/// The possible options are listed in the TPie::Paint() method.
276
278{
279 TString soption(option);
280 soption.ToLower();
281
282 if (soption.Length()==0) soption = "l";
283
284 if (gPad) {
285 if (!gPad->IsEditable()) gROOT->MakeDefCanvas();
286 if (!soption.Contains("same")) {
287 gPad->Clear();
288 gPad->Range(0.,0.,1.,1.);
289 }
290 }
291
292 for (Int_t i=0;i<fNvals;++i) fPieSlices[i]->AppendPad();
293 AppendPad(soption.Data());
294}
295
296////////////////////////////////////////////////////////////////////////////////
297/// This method is for internal use. It is used by Execute event to draw the
298/// outline of "this" TPie. Used when the opaque movements are not permitted.
299
301{
302 MakeSlices();
303
304 // XY metric
305 Double_t radXY = 1.;
306 if (fIs3D) {
307 radXY = TMath::Sin(fAngle3D/180.*TMath::Pi());
308 }
309
310 for (Int_t i = 0; i < fNvals && fIs3D;++i) {
311 Float_t minphi = (fSlices[i*2]+gAngularOffset+.5)*TMath::Pi()/180.;
312 Float_t avgphi = (fSlices[i*2+1]+gAngularOffset)*TMath::Pi()/180.;
313 Float_t maxphi = (fSlices[i*2+2]+gAngularOffset-.5)*TMath::Pi()/180.;
314
316 Double_t x0 = gX+radOffset*TMath::Cos(avgphi);
317 Double_t y0 = gY+radOffset*TMath::Sin(avgphi)*radXY-fHeight;
318
319 gVirtualX->DrawLine( gPad->XtoAbsPixel(x0), gPad->YtoAbsPixel(y0),
320 gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(minphi)),
321 gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(minphi)*radXY) );
322
323 Int_t ndiv = 10;
324 Double_t dphi = (maxphi-minphi)/ndiv;
325
326 if (dphi>.15) ndiv = (Int_t) ((maxphi-minphi)/.15);
327 dphi = (maxphi-minphi)/ndiv;
328
329 // Loop to draw the arc
330 for (Int_t j=0;j<ndiv;++j) {
331 Double_t phi = minphi+dphi*j;
332 gVirtualX->DrawLine( gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(phi)),
333 gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(phi)*radXY),
334 gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(phi+dphi)),
335 gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(phi+dphi)*radXY));
336 }
337
338 gVirtualX->DrawLine( gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(maxphi)),
339 gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(maxphi)*radXY),
340 gPad->XtoAbsPixel(x0), gPad->YtoAbsPixel(y0) );
341
342 gVirtualX->DrawLine(gPad->XtoAbsPixel(x0),
343 gPad->YtoAbsPixel(y0),
344 gPad->XtoAbsPixel(x0),
345 gPad->YtoAbsPixel(y0+fHeight));
346 gVirtualX->DrawLine(gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(minphi)),
347 gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(minphi)*radXY),
348 gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(minphi)),
349 gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(minphi)*radXY+fHeight));
350 gVirtualX->DrawLine(gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(maxphi)),
351 gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(maxphi)*radXY),
352 gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(maxphi)),
353 gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(maxphi)*radXY+fHeight));
354 }
355
356
357 // Loop over slices
358 for (Int_t i=0;i<fNvals;++i) {
359 Float_t minphi = (fSlices[i*2]+gAngularOffset+.5)*TMath::Pi()/180.;
360 Float_t avgphi = (fSlices[i*2+1]+gAngularOffset)*TMath::Pi()/180.;
361 Float_t maxphi = (fSlices[i*2+2]+gAngularOffset-.5)*TMath::Pi()/180.;
362
364 Double_t x0 = gX+radOffset*TMath::Cos(avgphi);
365 Double_t y0 = gY+radOffset*TMath::Sin(avgphi)*radXY;
366
367 gVirtualX->DrawLine( gPad->XtoAbsPixel(x0), gPad->YtoAbsPixel(y0),
368 gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(minphi)),
369 gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(minphi)*radXY) );
370
371
372 Int_t ndiv = 10;
373 Double_t dphi = (maxphi-minphi)/ndiv;
374
375 if (dphi>.15) ndiv = (Int_t) ((maxphi-minphi)/.15);
376 dphi = (maxphi-minphi)/ndiv;
377
378 // Loop to draw the arc
379 for (Int_t j=0;j<ndiv;++j) {
380 Double_t phi = minphi+dphi*j;
381 gVirtualX->DrawLine( gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(phi)),
382 gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(phi)*radXY),
383 gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(phi+dphi)),
384 gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(phi+dphi)*radXY));
385 }
386
387 gVirtualX->DrawLine( gPad->XtoAbsPixel(x0+gRadius*TMath::Cos(maxphi)),
388 gPad->YtoAbsPixel(y0+gRadius*TMath::Sin(maxphi)*radXY),
389 gPad->XtoAbsPixel(x0), gPad->YtoAbsPixel(y0) );
390 }
391}
392
393////////////////////////////////////////////////////////////////////////////////
394/// Execute the mouse events.
395
397{
398 if (!gPad) return;
399 if (!gPad->IsEditable() && event != kMouseEnter) return;
400
401 if (gCurrent_slice<=-10) {
402 gPad->SetCursor(kCross);
403 return;
404 }
405
406 MakeSlices();
407
408 static bool isMovingPie(kFALSE);
409 static bool isMovingSlice(kFALSE);
410 static bool isResizing(kFALSE);
411 static bool isRotating(kFALSE);
412 static bool onBorder(kFALSE);
413 bool isRedrawing(kFALSE);
414 static Int_t prev_event(-1);
415 static Int_t oldpx, oldpy;
416
417 // Portion of pie considered as "border"
418 const Double_t dr = gPad->PixeltoX(3);
419 const Double_t minRad = gPad->PixeltoX(10);
420
421 // Angular divisions in radial direction
422 const Double_t angstep1 = 0.5*TMath::PiOver4();
423 const Double_t angstep2 = 1.5*TMath::PiOver4();
424 const Double_t angstep3 = 2.5*TMath::PiOver4();
425 const Double_t angstep4 = 3.5*TMath::PiOver4();
426 const Double_t angstep5 = 4.5*TMath::PiOver4();
427 const Double_t angstep6 = 5.5*TMath::PiOver4();
428 const Double_t angstep7 = 6.5*TMath::PiOver4();
429 const Double_t angstep8 = 7.5*TMath::PiOver4();
430
431 // XY metric
432 Double_t radXY = 1.;
433 if (fIs3D) {
434 radXY = TMath::Sin(fAngle3D/180.*TMath::Pi());
435 }
436
437 Int_t dx, dy;
438 Double_t mdx, mdy;
439
440 switch(event) {
441 case kArrowKeyPress:
442 case kButton1Down:
443 // Change cursor to show pie's movement.
444 gVirtualX->SetLineColor(1);
445 gVirtualX->SetLineWidth(2);
446
447 // Current center and radius.
448 gX = fX;
449 gY = fY;
452 gAngularOffset = 0;
454
455 prev_event = kButton1Down;
456
457 case kMouseMotion:
458 if (gCurrent_rad>=fRadius-2.*dr && gCurrent_rad<=fRadius+dr
459 && !isMovingPie && !isMovingSlice && !isResizing) {
460 if (gCurrent_ang>=angstep8 || gCurrent_ang<angstep1)
461 gPad->SetCursor(kRightSide);
462 else if (gCurrent_ang>=angstep1 && gCurrent_ang<angstep2)
463 gPad->SetCursor(kTopRight);
464 else if (gCurrent_ang>=angstep2 && gCurrent_ang<angstep3)
465 gPad->SetCursor(kTopSide);
466 else if (gCurrent_ang>=angstep3 && gCurrent_ang<angstep4)
467 gPad->SetCursor(kTopLeft);
468 else if (gCurrent_ang>=angstep4 && gCurrent_ang<=angstep5)
469 gPad->SetCursor(kLeftSide);
470 else if (gCurrent_ang>=angstep5 && gCurrent_ang<angstep6)
471 gPad->SetCursor(kBottomLeft);
472 else if (gCurrent_ang>=angstep6 && gCurrent_ang<angstep7)
473 gPad->SetCursor(kBottomSide);
474 else if (gCurrent_ang>=angstep7 && gCurrent_ang<angstep8)
475 gPad->SetCursor(kBottomRight);
476 onBorder = kTRUE;
477 } else {
478 onBorder = kFALSE;
479 if (gCurrent_rad>fRadius*.6) {
480 gPad->SetCursor(kPointer);
481 } else if (gCurrent_rad<=fRadius*.3) {
482 gPad->SetCursor(kHand);
483 } else if (gCurrent_rad<=fRadius*.6 && gCurrent_rad>=fRadius*.3) {
484 gPad->SetCursor(kRotate);
485 }
486 }
487 oldpx = px;
488 oldpy = py;
489 if (isMovingPie || isMovingSlice) gPad->SetCursor(kMove);
490 break;
491
492 case kArrowKeyRelease:
493 case kButton1Motion:
494 if (!isMovingSlice || !isMovingPie || !isResizing || !isRotating) {
495 if (prev_event==kButton1Down) {
496 if (onBorder) {
497 isResizing = kTRUE;
498 } else if (gCurrent_rad>=fRadius*.6 && gCurrent_slice>=0) {
499 isMovingSlice = kTRUE;
500 } else if (gCurrent_rad<=fRadius*.3) {
501 isMovingPie = kTRUE;
502 } else if (gCurrent_rad<fRadius*.6 && gCurrent_rad>fRadius*.3) {
503 isRotating = kTRUE;
504 }
505 }
506 }
507
508 dx = px-oldpx;
509 dy = py-oldpy;
510
511 mdx = gPad->PixeltoX(dx);
512 mdy = gPad->PixeltoY(dy);
513
514 if (isMovingPie || isMovingSlice) {
515 gPad->SetCursor(kMove);
516 if (isMovingSlice) {
517 Float_t avgphi = fSlices[gCurrent_slice*2+1]*TMath::Pi()/180.;
518
519 if (!gPad->OpaqueMoving()) DrawGhost();
520
521 gRadiusOffset += TMath::Cos(avgphi)*mdx +TMath::Sin(avgphi)*mdy/radXY;
522 if (gRadiusOffset<0) gRadiusOffset = .0;
524
525 if (!gPad->OpaqueMoving()) DrawGhost();
526 } else {
527 if (!gPad->OpaqueMoving()) DrawGhost();
528
529 gX += mdx;
530 gY += mdy;
531
532 if (!gPad->OpaqueMoving()) DrawGhost();
533 }
534 } else if (isResizing) {
535 if (!gPad->OpaqueResizing()) DrawGhost();
536
538 if (gRadius+dr1>=minRad) {
539 gRadius += dr1;
540 } else {
541 gRadius = minRad;
542 }
543
544 if (!gPad->OpaqueResizing()) DrawGhost();
545 } else if (isRotating) {
546 if (!gPad->OpaqueMoving()) DrawGhost();
547
548 Double_t xx = gPad->AbsPixeltoX(px);
549 Double_t yy = gPad->AbsPixeltoY(py);
550
551 Double_t dx1 = xx-gX;
552 Double_t dy1 = yy-gY;
553
554 Double_t ang = TMath::ATan2(dy1,dx1);
555 if (ang<0) ang += TMath::TwoPi();
556
558
559 if (!gPad->OpaqueMoving()) DrawGhost();
560 }
561
562 oldpx = px;
563 oldpy = py;
564
565 if ( ((isMovingPie || isMovingSlice || isRotating) && gPad->OpaqueMoving()) ||
566 (isResizing && gPad->OpaqueResizing()) ) {
567 isRedrawing = kTRUE;
568 // event = kButton1Up;
569 // intentionally no break to continue with kButton1Up handling
570 }
571 else break;
572
573 case kButton1Up:
574 if (!isRedrawing) {
575 prev_event = kButton1Up;
577 }
578
579 if (gROOT->IsEscaped()) {
580 gROOT->SetEscape(kFALSE);
582 break;
583 }
584
585 fX = gX;
586 fY = gY;
590
591 if (isRedrawing && (isMovingPie || isMovingSlice)) gPad->SetCursor(kMove);
592
593 if (isMovingPie) isMovingPie = kFALSE;
594 if (isMovingSlice) isMovingSlice = kFALSE;
595 if (isResizing) isResizing = kFALSE;
596 if (isRotating) {
597 isRotating = kFALSE;
598 // this is important mainly when OpaqueMoving == kTRUE
600 }
601
602 gPad->Modified(kTRUE);
603
604
606
607 gVirtualX->SetLineColor(-1);
608 gVirtualX->SetLineWidth(-1);
609
610 break;
611 case kButton1Locate:
612
613 ExecuteEvent(kButton1Down, px, py);
614
615 while (true) {
616 px = py = 0;
617 event = gVirtualX->RequestLocator(1, 1, px, py);
618
620
621 if (event != -1) { // button is released
622 ExecuteEvent(kButton1Up, px, py);
623 return;
624 }
625 }
626 break;
627
628 case kMouseEnter:
629 break;
630
631 default:
632 // unknown event
633 break;
634 }
635}
636
637////////////////////////////////////////////////////////////////////////////////
638/// Returns the label of the entry number "i".
639
641{
642 return GetSlice(i)->GetTitle();
643}
644
645////////////////////////////////////////////////////////////////////////////////
646/// Return the color of the slice number "i".
647
649{
650 return GetSlice(i)->GetFillColor();
651}
652
653////////////////////////////////////////////////////////////////////////////////
654/// Return the style use to fill the slice number "i".
655
657{
658 return GetSlice(i)->GetFillStyle();
659}
660
661////////////////////////////////////////////////////////////////////////////////
662/// Return the line color used to outline thi "i" slice
663
665{
666 return GetSlice(i)->GetLineColor();
667}
668
669////////////////////////////////////////////////////////////////////////////////
670/// Return the style used to outline thi "i" slice
671
673{
674 return GetSlice(i)->GetLineStyle();
675}
676
677////////////////////////////////////////////////////////////////////////////////
678/// Return the line width used to outline thi "i" slice
679
681{
682 return GetSlice(i)->GetLineWidth();
683}
684
685////////////////////////////////////////////////////////////////////////////////
686/// Return the radial offset's value for the slice number "i".
687
689{
690 return GetSlice(i)->GetRadiusOffset();
691}
692
693////////////////////////////////////////////////////////////////////////////////
694/// Return the value associated with the slice number "i".
695
697{
698 return GetSlice(i)->GetValue();
699}
700
701////////////////////////////////////////////////////////////////////////////////
702/// If created before by Paint option or by MakeLegend method return
703/// the pointer to the legend, otherwise return 0;
704
706{
707 return fLegend;
708}
709
710////////////////////////////////////////////////////////////////////////////////
711/// Return the reference to the slice of index 'id'. There are no controls
712/// of memory corruption, be carefull.
713
715{
716 return fPieSlices[id];
717}
718
719////////////////////////////////////////////////////////////////////////////////
720/// Common initialization for all constructors.
721/// This is a private function called to allocate the memory.
722
724{
726
727 fAngularOffset = ao;
728 fX = x;
729 fY = y;
730 fRadius = r;
731 fNvals = np;
732 fSum = 0.;
733 fSlices = nullptr;
734 fLegend = nullptr;
735 fHeight = 0.08;
736 fAngle3D = 30;
737 fIs3D = kFALSE;
738
740
742
743 for (Int_t i=0;i<fNvals;++i) {
744 TString tmplbl = "Slice";
745 tmplbl += i;
746 fPieSlices[i] = new TPieSlice(tmplbl.Data(), tmplbl.Data(), this);
752 fPieSlices[i]->SetFillStyle(1001);
753 }
754
755 fLabelFormat = "%txt";
756 fFractionFormat = "%3.2f";
757 fValueFormat = "%4.2f";
758 fPercentFormat = "%3.1f";
759}
760
761////////////////////////////////////////////////////////////////////////////////
762/// This method create a legend that explains the contents
763/// of the slice for this pie-chart.
764///
765/// The parameter passed reppresents the option passed to shown the slices,
766/// see TLegend::AddEntry() for further details.
767///
768/// The pointer of the TLegend is returned.
769
771{
772 if (!fLegend) fLegend = new TLegend(x1,y1,x2,y2,leg_header);
773 else fLegend->Clear();
774
775 for (Int_t i=0;i<fNvals;++i) {
777 }
778
779 if (gPad) fLegend->Draw();
780
781 return fLegend;
782}
783
784////////////////////////////////////////////////////////////////////////////////
785/// Paint a Pie chart in a canvas.
786/// The possible option are:
787///
788/// - "R" Print the labels along the central "R"adius of slices.
789/// - "T" Print the label in a direction "T"angent to circle that describes
790/// the TPie.
791/// - "SC" Paint the labels with the "S"ame "C"olor as the slices.
792/// - "3D" Draw the pie-chart with a pseudo 3D effect.
793/// - "NOL" No OutLine: Don't draw the slices' outlines, any property over the
794/// slices' line is ignored.
795/// - ">" Sort the slices in increasing order.
796/// - "<" Sort the slices in decreasing order.
797///
798/// After the use of > or < options the internal order of the TPieSlices
799/// is changed.
800///
801/// Other options changing the labels' format are described in
802/// TPie::SetLabelFormat().
803
805{
806 MakeSlices();
807
808 TString soption(option);
809
810 Bool_t optionSame = kFALSE;
811
812 // if true the lines around the slices are drawn, if false not
813 Bool_t optionLine = kTRUE;
814
815 // if true the labels' colors are the same as the slices' colors
816 Bool_t optionSameColor = kFALSE;
817
818 // For the label orientation there are 3 possibilities:
819 // 0: horizontal
820 // 1: radial
821 // 2: tangent
822 Int_t lblor = 0;
823
824 // Parse the options
825 Int_t idx;
826 // Paint the TPie in an existing canvas
827 if ( (idx=soption.Index("same"))>=0 ) {
828 optionSame = kTRUE;
829 soption.Remove(idx,4);
830 }
831
832 if ( (idx=soption.Index("nol"))>=0 ) {
833 optionLine = kFALSE;
834 soption.Remove(idx,3);
835 }
836
837 if ( (idx=soption.Index("sc"))>=0 ) {
838 optionSameColor = kTRUE;
839 soption.Remove(idx,2);
840 }
841
842 // check if is active the pseudo-3d
843 if ( (idx=soption.Index("3d"))>=0 ) {
844 fIs3D = kTRUE;
845 soption.Remove(idx,2);
846 } else {
847 fIs3D = kFALSE;
848 }
849
850 // seek if have to draw the labels around the pie chart
851 if ( (idx=soption.Index("t"))>=0 ) {
852 lblor = 2;
853 soption.Remove(idx,1);
854 }
855
856 // Seek if have to paint the labels along the radii
857 if ( (idx=soption.Index("r"))>=0 ) {
858 lblor = 1;
859 soption.Remove(idx,1);
860 }
861
862 // Seeks if has to paint sort the slices in increasing mode
863 if ( (idx=soption.Index(">"))>=0 ) {
865 soption.Remove(idx,1);
866 }
867
868 // Seeks if has to paint sort the slices in decreasing mode
869 if ( (idx=soption.Index("<"))>=0 ) {
871 soption.Remove(idx,1);
872 }
873
874 if (fNvals<=0) {
875 Warning("Paint","No vals");
876 return;
877 }
878
879 if (!fPieSlices) {
880 Warning("Paint","No valid arrays of values");
881 return;
882 }
883
884 // Check if gPad exists and define the drawing range.
885 if (!gPad) return;
886
887 // Objects useful to draw labels and slices
888 TLatex textlabel;
889 TArc arc;
890 TLine line;
891
892 // XY metric
893 Double_t radX = fRadius;
894 Double_t radY = fRadius;
895 Double_t radXY = 1.;
896
897 if (fIs3D) {
898 radXY = TMath::Sin(fAngle3D/180.*TMath::Pi());
899 radY = fRadius*radXY;
900 }
901
902 // Draw the slices.
903 Int_t pixelHeight = gPad->YtoPixel(0)-gPad->YtoPixel(fHeight);
904 for (Int_t pi = 0; pi < pixelHeight && fIs3D; ++pi) { // loop for pseudo-3d effect
905 for (Int_t i=0;i<fNvals;++i) {
906 // draw the arc
907 // set the color of the next slice
908 if (pi>0) {
909 arc.SetFillStyle(0);
910 arc.SetLineColor(TColor::GetColorDark((fPieSlices[i]->GetFillColor())));
911 } else {
912 arc.SetFillStyle(0);
913 if (optionLine) {
914 arc.SetLineColor(fPieSlices[i]->GetLineColor());
915 arc.SetLineStyle(fPieSlices[i]->GetLineStyle());
916 arc.SetLineWidth(fPieSlices[i]->GetLineWidth());
917 } else {
918 arc.SetLineWidth(1);
919 arc.SetLineColor(TColor::GetColorDark((fPieSlices[i]->GetFillColor())));
920 }
921 }
922 // Paint the slice
923 Float_t aphi = fSlices[2*i+1]*TMath::Pi()/180.;
924
926 Double_t ay = fY+TMath::Sin(aphi)*fPieSlices[i]->GetRadiusOffset()*radXY+gPad->PixeltoY(pixelHeight-pi);
927
928 arc.PaintEllipse(ax, ay, radX, radY, fSlices[2*i],
929 fSlices[2*i+2], 0.);
930
931 if (optionLine) {
932 line.SetLineColor(fPieSlices[i]->GetLineColor());
933 line.SetLineStyle(fPieSlices[i]->GetLineStyle());
934 line.SetLineWidth(fPieSlices[i]->GetLineWidth());
935 line.PaintLine(ax,ay,ax,ay);
936
937 Double_t x0, y0;
938 x0 = ax+radX*TMath::Cos(fSlices[2*i]/180.*TMath::Pi());
939 y0 = ay+radY*TMath::Sin(fSlices[2*i]/180.*TMath::Pi());
940 line.PaintLine(x0,y0,x0,y0);
941
942 x0 = ax+radX*TMath::Cos(fSlices[2*i+2]/180.*TMath::Pi());
943 y0 = ay+radY*TMath::Sin(fSlices[2*i+2]/180.*TMath::Pi());
944 line.PaintLine(x0,y0,x0,y0);
945 }
946 }
947 } // end loop for pseudo-3d effect
948
949 for (Int_t i=0;i<fNvals;++i) { // loop for the piechart
950 // Set the color of the next slice
951 arc.SetFillColor(fPieSlices[i]->GetFillColor());
952 arc.SetFillStyle(fPieSlices[i]->GetFillStyle());
953 if (optionLine) {
954 arc.SetLineColor(fPieSlices[i]->GetLineColor());
955 arc.SetLineStyle(fPieSlices[i]->GetLineStyle());
956 arc.SetLineWidth(fPieSlices[i]->GetLineWidth());
957 } else {
958 arc.SetLineWidth(1);
959 arc.SetLineColor(fPieSlices[i]->GetFillColor());
960 }
961
962 // Paint the slice
963 Float_t aphi = fSlices[2*i+1]*TMath::Pi()/180.;
964
966 Double_t ay = fY+TMath::Sin(aphi)*fPieSlices[i]->GetRadiusOffset()*radXY;
967 arc.PaintEllipse(ax, ay, radX, radY, fSlices[2*i],
968 fSlices[2*i+2], 0.);
969
970 } // end loop to draw the slices
971
972
973 // Set the font
974 textlabel.SetTextFont(GetTextFont());
975 textlabel.SetTextSize(GetTextSize());
976 textlabel.SetTextColor(GetTextColor());
977
978 // Loop to place the labels.
979 for (Int_t i=0;i<fNvals;++i) {
980 Float_t aphi = fSlices[2*i+1]*TMath::Pi()/180.;
981 //aphi = TMath::ATan2(TMath::Sin(aphi)*radXY,TMath::Cos(aphi));
982
983 Float_t label_off = fLabelsOffset;
984
985
986 // Paint the text in the pad
987 TString tmptxt = fLabelFormat;
988
989 tmptxt.ReplaceAll("%txt",fPieSlices[i]->GetTitle());
992 tmptxt.ReplaceAll("%perc",TString::Format(TString::Format("%s %s",fPercentFormat.Data(),"%s").Data(),(fPieSlices[i]->GetValue()/fSum)*100,"%"));
993
994 textlabel.SetTitle(tmptxt.Data());
995 Double_t h = textlabel.GetYsize();
996 Double_t w = textlabel.GetXsize();
997
998 Float_t lx = fX+(fRadius+fPieSlices[i]->GetRadiusOffset()+label_off)*TMath::Cos(aphi);
999 Float_t ly = fY+(fRadius+fPieSlices[i]->GetRadiusOffset()+label_off)*TMath::Sin(aphi)*radXY;
1000
1001 Double_t lblang = 0;
1002
1003 if (lblor==1) { // radial direction for the label
1004 aphi = TMath::ATan2(TMath::Sin(aphi)*radXY,TMath::Cos(aphi));
1005 lblang += aphi;
1006 if (lblang<=0) lblang += TMath::TwoPi();
1007 if (lblang>TMath::TwoPi()) lblang-= TMath::TwoPi();
1008
1009 lx += h/2.*TMath::Sin(lblang);
1010 ly -= h/2.*TMath::Cos(lblang);
1011
1012 // This control prevent text up-side
1013 if (lblang>TMath::PiOver2() && lblang<=3.*TMath::PiOver2()) {
1014 lx += w*TMath::Cos(lblang)-h*TMath::Sin(lblang);
1015 ly += w*TMath::Sin(lblang)+h*TMath::Cos(lblang);
1016 lblang -= TMath::Pi();
1017 }
1018 } else if (lblor==2) { // tangential direction of the labels
1019 aphi -=TMath::PiOver2();
1020 aphi = TMath::ATan2(TMath::Sin(aphi)*radXY,TMath::Cos(aphi));
1021 lblang += aphi;//-TMath::PiOver2();
1022 if (lblang<0) lblang+=TMath::TwoPi();
1023
1024 lx -= w/2.*TMath::Cos(lblang);
1025 ly -= w/2.*TMath::Sin(lblang);
1026
1027 if (lblang>TMath::PiOver2() && lblang<3.*TMath::PiOver2()) {
1028 lx += w*TMath::Cos(lblang)-h*TMath::Sin(lblang);
1029 ly += w*TMath::Sin(lblang)+h*TMath::Cos(lblang);
1030 lblang -= TMath::Pi();
1031 }
1032 } else { // horizontal labels (default direction)
1033 aphi = TMath::ATan2(TMath::Sin(aphi)*radXY,TMath::Cos(aphi));
1034 if (aphi>TMath::PiOver2() || aphi<=-TMath::PiOver2()) lx -= w;
1035 if (aphi<0) ly -= h;
1036 }
1037
1038 Float_t rphi = TMath::ATan2((ly-fY)*radXY,lx-fX);
1039 if (rphi < 0 && fIs3D && label_off>=0.)
1040 ly -= fHeight;
1041
1042 if (optionSameColor) textlabel.SetTextColor((fPieSlices[i]->GetFillColor()));
1043 textlabel.PaintLatex(lx,ly,
1044 lblang*180/TMath::Pi()+GetTextAngle(),
1045 GetTextSize(), tmptxt.Data());
1046 }
1047
1048 if (optionSame) return;
1049
1050 // Draw title
1051 TPaveText *title = nullptr;
1052 if (auto obj = gPad->GetListOfPrimitives()->FindObject("title")) {
1053 title = dynamic_cast<TPaveText*>(obj);
1054 }
1055
1056 // Check the OptTitle option
1057 if (strlen(GetTitle()) == 0 || gStyle->GetOptTitle() <= 0) {
1058 if (title) delete title;
1059 return;
1060 }
1061
1062 // Height and width of the title
1063 Double_t ht = gStyle->GetTitleH();
1064 Double_t wt = gStyle->GetTitleW();
1065 if (ht<=0) ht = 1.1*gStyle->GetTitleFontSize();
1066 if (ht<=0) ht = 0.05; // minum height
1067 if (wt<=0) { // eval the width of the title
1068 TLatex l;
1069 l.SetTextSize(ht);
1070 l.SetTitle(GetTitle());
1071 // adjustment in case the title has several lines (#splitline)
1072 ht = TMath::Max(ht, 1.2*l.GetYsize()/(gPad->GetY2() - gPad->GetY1()));
1073 Double_t wndc = l.GetXsize()/(gPad->GetX2() - gPad->GetX1());
1074 wt = TMath::Min(0.7, 0.02+wndc);
1075 }
1076
1077 if (title) {
1078 TText *t0 = (TText*)title->GetLine(0);
1079 if (t0) {
1080 if (!strcmp(t0->GetTitle(),GetTitle())) return;
1081 t0->SetTitle(GetTitle());
1082 if (wt > 0) title->SetX2NDC(title->GetX1NDC()+wt);
1083 }
1084 return;
1085 }
1086
1087 Int_t talh = gStyle->GetTitleAlign()/10;
1088 if (talh < 1) talh = 1; else if (talh > 3) talh = 3;
1089 Int_t talv = gStyle->GetTitleAlign()%10;
1090 if (talv < 1) talv = 1; else if (talv > 3) talv = 3;
1092 xpos = gStyle->GetTitleX();
1093 ypos = gStyle->GetTitleY();
1094 if (talh == 2) xpos = xpos-wt/2.;
1095 if (talh == 3) xpos = xpos-wt;
1096 if (talv == 2) ypos = ypos+ht/2.;
1097 if (talv == 1) ypos = ypos+ht;
1098
1099 title = new TPaveText(xpos,ypos-ht,xpos+wt,ypos,"blNDC");
1102 title->SetName("title");
1103
1106 title->SetTextFont(gStyle->GetTitleFont(""));
1107 if (gStyle->GetTitleFont("")%10 > 2)
1109 title->AddText(GetTitle());
1110
1111 title->SetBit(kCanDelete);
1112
1113 title->Draw();
1114 title->Paint();
1115}
1116
1117////////////////////////////////////////////////////////////////////////////////
1118/// Save primitive as a C++ statement(s) on output stream out
1119
1120void TPie::SavePrimitive(std::ostream &out, Option_t *option)
1121{
1122 out << " " << std::endl;
1123 if (gROOT->ClassSaved(TPie::Class()))
1124 out << " ";
1125 else
1126 out << " TPie *";
1127
1128 out << "pie = new TPie(\"" << GetName() << "\", \"" << GetTitle()
1129 << "\", " << fNvals << ");" << std::endl;
1130 out << " pie->SetCircle(" << fX << ", " << fY << ", " << fRadius << ");" << std::endl;
1131 out << " pie->SetValueFormat(\"" << GetValueFormat() << "\");" << std::endl;
1132 out << " pie->SetLabelFormat(\"" << GetLabelFormat() << "\");" << std::endl;
1133 out << " pie->SetPercentFormat(\"" << GetPercentFormat() << "\");" << std::endl;
1134 out << " pie->SetLabelsOffset(" << GetLabelsOffset() << ");" << std::endl;
1135 out << " pie->SetAngularOffset(" << GetAngularOffset() << ");" << std::endl;
1136
1137 SaveTextAttributes(out,"pie",11,0,1,62,0.05);
1138
1139 // Save the values for the slices
1140 for (Int_t i = 0; i < fNvals; ++i) {
1141 auto slice_name = TString::Format("pie->GetSlice(%d)", i);
1142 fPieSlices[i]->SavePrimitive(out, slice_name.Data());
1143 }
1144
1145 out << " pie->Draw(\"" << option << "\");" << std::endl;
1146}
1147
1148////////////////////////////////////////////////////////////////////////////////
1149/// Set the value of for the pseudo 3D view angle, in degree.
1150/// The range of the permitted values is: [0,90]
1151
1153 // check if val is in the permitted range
1154 while (val>360.) val -= 360.;
1155 while (val<0) val += 360.;
1156 if (val>=90 && val<180) val = 180-val;
1157 else if (val>=180 && val<=360) val = 360-val;
1158
1159 fAngle3D = val;
1160}
1161
1162////////////////////////////////////////////////////////////////////////////////
1163/// Set the global angular offset for slices in degree [0,360]
1164
1166{
1168
1169 while (fAngularOffset>=360.) fAngularOffset -= 360.;
1170 while (fAngularOffset<0.) fAngularOffset += 360.;
1171
1173}
1174
1175////////////////////////////////////////////////////////////////////////////////
1176/// Set the coordinates of the circle that describe the pie:
1177/// - the 1st and the 2nd arguments are the x and y center's coordinates.
1178/// - the 3rd value is the pie-chart's radius.
1179///
1180/// All the coordinates are in NDC space.
1181
1183{
1184 fX = x;
1185 fY = y;
1186 fRadius = rad;
1187}
1188
1189////////////////////////////////////////////////////////////////////////////////
1190/// Set slice number "i" label. The first parameter is the index of the slice,
1191/// the other is the label text.
1192
1193void TPie::SetEntryLabel(Int_t i, const char *text)
1194{
1195 // Set the Label of a single slice
1196 if (i>=0 && i<fNvals) fPieSlices[i]->SetTitle(text);
1197}
1198
1199////////////////////////////////////////////////////////////////////////////////
1200/// Set the color for the slice's outline. "i" is the slice number.
1201
1203{
1204 if (i>=0 && i<fNvals) fPieSlices[i]->SetLineColor(color);
1205}
1206
1207////////////////////////////////////////////////////////////////////////////////
1208/// Set the style for the slice's outline. "i" is the slice number.
1209
1211{
1212 if (i>=0 && i<fNvals) fPieSlices[i]->SetLineStyle(style);
1213}
1214
1215////////////////////////////////////////////////////////////////////////////////
1216/// Set the width of the slice's outline. "i" is the slice number.
1217
1219{
1220 if (i>=0 && i<fNvals) fPieSlices[i]->SetLineWidth(width);
1221}
1222
1223////////////////////////////////////////////////////////////////////////////////
1224/// Set the color for the slice "i".
1225
1227{
1228 if (i>=0 && i<fNvals) fPieSlices[i]->SetFillColor(color);
1229}
1230
1231////////////////////////////////////////////////////////////////////////////////
1232/// Set the fill style for the "i" slice
1233
1235{
1236 if (i>=0 && i<fNvals) fPieSlices[i]->SetFillStyle(style);
1237}
1238
1239////////////////////////////////////////////////////////////////////////////////
1240/// Set the distance, in the direction of the radius of the slice.
1241
1243{
1244 if (i>=0 && i<fNvals) fPieSlices[i]->SetRadiusOffset(shift);
1245}
1246
1247////////////////////////////////////////////////////////////////////////////////
1248/// Set the value of a slice
1249
1251{
1252 if (i>=0 && i<fNvals) fPieSlices[i]->SetValue(val);
1253
1255}
1256
1257////////////////////////////////////////////////////////////////////////////////
1258/// Set the fill colors for all the TPie's slices.
1259
1261{
1262 if (!colors) return;
1263 for (Int_t i=0;i<fNvals;++i) fPieSlices[i]->SetFillColor(colors[i]);
1264}
1265
1266////////////////////////////////////////////////////////////////////////////////
1267/// Set the height, in pixel, for the piechart if is drawn using
1268/// the pseudo-3d mode.
1269///
1270/// The default value is 20 pixel.
1271
1273{
1274 fHeight = val;
1275}
1276
1277////////////////////////////////////////////////////////////////////////////////
1278/// This method is used to customize the label format. The format string
1279/// must contain one of these modifiers:
1280///
1281/// - %txt : to print the text label associated with the slice
1282/// - %val : to print the numeric value of the slice
1283/// - %frac : to print the relative fraction of this slice
1284/// - %perc : to print the % of this slice
1285///
1286/// ex. : mypie->SetLabelFormat("%txt (%frac)");
1287
1288void TPie::SetLabelFormat(const char *fmt)
1289{
1290 fLabelFormat = fmt;
1291}
1292
1293////////////////////////////////////////////////////////////////////////////////
1294/// Set numeric format in the label, is used if the label format
1295/// there is the modifier %frac, in this case the value is printed
1296/// using this format.
1297///
1298/// The numeric format use the standard C modifier used in stdio library:
1299/// %f, %2.1$, %e... for further documentation you can use the printf
1300/// man page ("man 3 printf" on linux)
1301///
1302/// Example:
1303/// ~~~ {.cpp}
1304/// mypie->SetLabelFormat("%txt (%frac)");
1305/// mypie->SetFractionFormat("2.1f");
1306/// ~~~
1307
1308void TPie::SetFractionFormat(const char *fmt)
1309{
1310 fFractionFormat = fmt;
1311}
1312
1313////////////////////////////////////////////////////////////////////////////////
1314/// Set the labels for all the slices.
1315
1316void TPie::SetLabels(const char *lbls[])
1317{
1318 if (!lbls) return;
1319 for (Int_t i=0;i<fNvals;++i) fPieSlices[i]->SetTitle(lbls[i]);
1320}
1321
1322////////////////////////////////////////////////////////////////////////////////
1323/// Set the distance between the label end the external line of the TPie.
1324
1326{
1327 fLabelsOffset = labelsoffset;
1328}
1329
1330////////////////////////////////////////////////////////////////////////////////
1331/// Set the numeric format for the percent value of a slice, default: %3.1f
1332
1333void TPie::SetPercentFormat(const char *fmt)
1334{
1335 fPercentFormat = fmt;
1336}
1337
1338////////////////////////////////////////////////////////////////////////////////
1339/// Set the pie chart's radius' value.
1340
1342{
1343 if (rad>0) {
1344 fRadius = rad;
1345 } else {
1346 Warning("SetRadius",
1347 "It's not possible set the radius to a negative value");
1348 }
1349}
1350
1351////////////////////////////////////////////////////////////////////////////////
1352/// Set the numeric format the slices' values.
1353/// Used by %val (see SetLabelFormat()).
1354
1355void TPie::SetValueFormat(const char *fmt)
1356{
1357 fValueFormat = fmt;
1358}
1359
1360////////////////////////////////////////////////////////////////////////////////
1361/// Set X value.
1362
1364{
1365 fX = x;
1366}
1367
1368////////////////////////////////////////////////////////////////////////////////
1369/// Set Y value.
1370
1372{
1373 fY = y;
1374}
1375
1376////////////////////////////////////////////////////////////////////////////////
1377/// Make the slices.
1378/// If they already exist it does nothing unless force=kTRUE.
1379
1381{
1382 if (fSlices && !force) return;
1383
1384 fSum = .0;
1385
1386 for (Int_t i=0;i<fNvals;++i) {
1387 if (fPieSlices[i]->GetValue()<0) {
1388 Warning("MakeSlices",
1389 "Negative values in TPie, absolute value will be used");
1390 fPieSlices[i]->SetValue(-1.*fPieSlices[i]->GetValue());
1391 }
1392 fSum += fPieSlices[i]->GetValue();
1393 }
1394
1395 if (fSum<=.0) return;
1396
1397 if (!fSlices) fSlices = new Float_t[2*fNvals+1];
1398
1399 // Compute the slices size and position (2 angles for each slice)
1401 for (Int_t i=0;i<fNvals;++i) {
1402 Float_t dphi = fPieSlices[i]->GetValue()/fSum*360.;
1403 fSlices[2*i+1] = fSlices[2*i]+dphi/2.;
1404 fSlices[2*i+2] = fSlices[2*i]+dphi;
1405 }
1406}
1407
1408////////////////////////////////////////////////////////////////////////////////
1409/// This method, mainly intended for internal use, ordered the slices according their values.
1410/// The default (amode=kTRUE) is increasing order, but is also possible in decreasing order (amode=kFALSE).
1411///
1412/// If the merge_threshold>0 the slice that contains a quantity smaller than merge_threshold are merged
1413/// together
1414
1415void TPie::SortSlices(Bool_t amode, Float_t merge_threshold)
1416{
1417
1418 // main loop to order, bubble sort, the array
1419 Bool_t isDone = kFALSE;
1420
1421 while (isDone==kFALSE) {
1422 isDone = kTRUE;
1423
1424 for (Int_t i=0;i<fNvals-1;++i) { // loop over the values
1425 if ( (amode && (fPieSlices[i]->GetValue()>fPieSlices[i+1]->GetValue())) ||
1426 (!amode && (fPieSlices[i]->GetValue()<fPieSlices[i+1]->GetValue()))
1427 )
1428 {
1429 // exchange the order
1430 TPieSlice *tmpcpy = fPieSlices[i];
1431 fPieSlices[i] = fPieSlices[i+1];
1432 fPieSlices[i+1] = tmpcpy;
1433
1434 isDone = kFALSE;
1435 }
1436 } // end loop the values
1437 } // end main ordering loop
1438
1439 if (merge_threshold>0) {
1440 // merge smallest slices
1441 TPieSlice *merged_slice = new TPieSlice("merged","other",this);
1442 merged_slice->SetRadiusOffset(0.);
1443 merged_slice->SetLineColor(1);
1444 merged_slice->SetLineStyle(1);
1445 merged_slice->SetLineWidth(1);
1446 merged_slice->SetFillColor(gStyle->GetColorPalette( (amode ? 0 : fNvals-1) ));
1447 merged_slice->SetFillStyle(1001);
1448
1449 if (amode) {
1450 // search slices under the threshold
1451 Int_t iMerged = 0;
1452 for (;iMerged<fNvals&&fPieSlices[iMerged]->GetValue()<merge_threshold;++iMerged) {
1453 merged_slice->SetValue( merged_slice->GetValue()+fPieSlices[iMerged]->GetValue() );
1454 }
1455
1456 // evaluate number of valid slices
1457 if (iMerged<=1) { // no slices to merge
1458 delete merged_slice;
1459 }
1460 else { // write a new array with the right dimension
1461 Int_t old_fNvals = fNvals;
1462 fNvals = fNvals-iMerged+1;
1463 TPieSlice **new_array = new TPieSlice*[fNvals];
1464 new_array[0] = merged_slice;
1465 for (Int_t i=0;i<old_fNvals;++i) {
1466 if (i<iMerged) delete fPieSlices[i];
1467 else new_array[i-iMerged+1] = fPieSlices[i];
1468 }
1469 delete [] fPieSlices;
1470 fPieSlices = new_array;
1471 }
1472 }
1473 else {
1474 Int_t iMerged = fNvals-1;
1475 for (;iMerged>=0&&fPieSlices[iMerged]->GetValue()<merge_threshold;--iMerged) {
1476 merged_slice->SetValue( merged_slice->GetValue()+fPieSlices[iMerged]->GetValue() );
1477 }
1478
1479 // evaluate number of valid slices
1480 Int_t nMerged = fNvals-1-iMerged;
1481 if (nMerged<=1) { // no slices to merge
1482 delete merged_slice;
1483 }
1484 else { // write a new array with the right dimension
1485 Int_t old_fNvals = fNvals;
1486 fNvals = fNvals-nMerged+1;
1487 TPieSlice **new_array = new TPieSlice*[fNvals];
1488 new_array[fNvals-1] = merged_slice;
1489 for (Int_t i=old_fNvals-1;i>=0;--i) {
1490 if (i>iMerged) delete fPieSlices[i];
1491 else new_array[i-nMerged-1] = fPieSlices[i];
1492 }
1493 delete [] fPieSlices;
1494 fPieSlices = new_array;
1495 }
1496
1497 }
1498 }
1499
1501}
1502
@ kMouseMotion
Definition Buttons.h:23
@ kArrowKeyRelease
Definition Buttons.h:21
@ kButton1Motion
Definition Buttons.h:20
@ kButton1Up
Definition Buttons.h:19
@ kArrowKeyPress
Definition Buttons.h:21
@ kButton1Down
Definition Buttons.h:17
@ kButton1Locate
Definition Buttons.h:22
@ kMouseEnter
Definition Buttons.h:23
@ kRightSide
Definition GuiTypes.h:373
@ kBottomSide
Definition GuiTypes.h:373
@ kTopLeft
Definition GuiTypes.h:372
@ kBottomRight
Definition GuiTypes.h:372
@ kTopSide
Definition GuiTypes.h:373
@ kLeftSide
Definition GuiTypes.h:373
@ kMove
Definition GuiTypes.h:374
@ kTopRight
Definition GuiTypes.h:372
@ kBottomLeft
Definition GuiTypes.h:372
@ kHand
Definition GuiTypes.h:374
@ kCross
Definition GuiTypes.h:374
@ kRotate
Definition GuiTypes.h:374
@ kPointer
Definition GuiTypes.h:375
#define h(i)
Definition RSha256.hxx:106
bool Bool_t
Definition RtypesCore.h:63
int Int_t
Definition RtypesCore.h:45
float Float_t
Definition RtypesCore.h:57
constexpr Bool_t kFALSE
Definition RtypesCore.h:101
double Double_t
Definition RtypesCore.h:59
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
const char Option_t
Definition RtypesCore.h:66
#define ClassImp(name)
Definition Rtypes.h:377
Option_t Option_t option
Option_t Option_t SetTextSize
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h offset
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t np
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize id
Option_t Option_t TPoint TPoint const char x2
Option_t Option_t TPoint TPoint const char x1
Option_t Option_t SetTextFont
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void xpos
Option_t Option_t TPoint TPoint const char y2
Option_t Option_t SetFillColor
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void ypos
Option_t Option_t width
Option_t Option_t style
Option_t Option_t TPoint TPoint const char text
Option_t Option_t TPoint TPoint const char y1
char name[80]
Definition TGX11.cxx:110
Double_t gCurrent_ang
Definition TPie.cxx:58
Double_t gX
Definition TPie.cxx:44
Double_t gCurrent_phi1
Definition TPie.cxx:52
Double_t gCurrent_phi2
Definition TPie.cxx:53
Double_t gCurrent_y
Definition TPie.cxx:57
Double_t gRadiusOffset
Definition TPie.cxx:47
Double_t gAngularOffset
Definition TPie.cxx:48
Double_t gCurrent_x
Definition TPie.cxx:56
Double_t gCurrent_rad
Definition TPie.cxx:54
Double_t gRadius
Definition TPie.cxx:46
Int_t gCurrent_slice
Definition TPie.cxx:51
Bool_t gIsUptSlice
Definition TPie.cxx:49
Double_t gY
Definition TPie.cxx:45
#define gROOT
Definition TROOT.h:407
R__EXTERN TStyle * gStyle
Definition TStyle.h:436
#define gPad
#define gVirtualX
Definition TVirtualX.h:337
Color * colors
Definition X3DBuffer.c:21
Create an Arc.
Definition TArc.h:26
virtual Color_t GetLabelColor() const
Definition TAttAxis.h:38
virtual Style_t GetLabelFont() const
Definition TAttAxis.h:39
virtual Float_t GetLabelSize() const
Definition TAttAxis.h:41
virtual Color_t GetFillColor() const
Return the fill area color.
Definition TAttFill.h:30
virtual Style_t GetFillStyle() const
Return the fill area style.
Definition TAttFill.h:31
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition TAttFill.h:37
virtual void SetFillStyle(Style_t fstyle)
Set the fill area style.
Definition TAttFill.h:39
virtual Color_t GetLineColor() const
Return the line color.
Definition TAttLine.h:33
virtual void SetLineStyle(Style_t lstyle)
Set the line style.
Definition TAttLine.h:42
virtual Width_t GetLineWidth() const
Return the line width.
Definition TAttLine.h:35
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
Definition TAttLine.h:43
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition TAttLine.h:40
virtual Style_t GetLineStyle() const
Return the line style.
Definition TAttLine.h:34
Text Attributes class.
Definition TAttText.h:18
virtual Float_t GetTextSize() const
Return the text size.
Definition TAttText.h:36
virtual Font_t GetTextFont() const
Return the text font.
Definition TAttText.h:35
virtual Color_t GetTextColor() const
Return the text color.
Definition TAttText.h:34
virtual Float_t GetTextAngle() const
Return the text angle.
Definition TAttText.h:33
virtual void SetTextColor(Color_t tcolor=1)
Set the text color.
Definition TAttText.h:44
virtual void SetTextFont(Font_t tfont=62)
Set the text font.
Definition TAttText.h:46
virtual void SaveTextAttributes(std::ostream &out, const char *name, Int_t alidef=12, Float_t angdef=0, Int_t coldef=1, Int_t fondef=61, Float_t sizdef=1)
Save text attributes as C++ statement(s) on output stream out.
Definition TAttText.cxx:373
virtual void SetTextSize(Float_t tsize=1)
Set the text size.
Definition TAttText.h:47
Class to manage histogram axis.
Definition TAxis.h:31
const char * GetBinLabel(Int_t bin) const
Return label for bin.
Definition TAxis.cxx:440
Int_t GetLast() const
Return last bin on the axis i.e.
Definition TAxis.cxx:469
Int_t GetFirst() const
Return first bin on the axis i.e.
Definition TAxis.cxx:458
THashList * GetLabels() const
Definition TAxis.h:121
static Int_t GetColorDark(Int_t color)
Static function: Returns the dark color number corresponding to n If the TColor object does not exist...
Definition TColor.cxx:2047
virtual void PaintEllipse(Double_t x1, Double_t y1, Double_t r1, Double_t r2, Double_t phimin, Double_t phimax, Double_t theta, Option_t *option="")
Draw this ellipse with new coordinates.
Definition TEllipse.cxx:562
TH1 is the base class of all histogram classes in ROOT.
Definition TH1.h:59
To draw Mathematical Formula.
Definition TLatex.h:18
Double_t GetXsize()
Return size of the formula along X in pad coordinates when the text precision is smaller than 3.
Definition TLatex.cxx:2569
Double_t GetYsize()
Return size of the formula along Y in pad coordinates when the text precision is smaller than 3.
Definition TLatex.cxx:2657
virtual void PaintLatex(Double_t x, Double_t y, Double_t angle, Double_t size, const char *text)
Main drawing function.
Definition TLatex.cxx:2114
This class displays a legend box (TPaveText) containing several legend entries.
Definition TLegend.h:23
TLegendEntry * AddEntry(const TObject *obj, const char *label="", Option_t *option="lpf")
Add a new entry to this legend.
Definition TLegend.cxx:320
void Draw(Option_t *option="") override
Draw this legend with its current attributes.
Definition TLegend.cxx:425
void Clear(Option_t *option="") override
Clear all entries in this legend, including the header.
Definition TLegend.cxx:379
Use the TLine constructor to create a simple line.
Definition TLine.h:22
virtual void PaintLine(Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Draw this line with new coordinates.
Definition TLine.cxx:399
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:164
const char * GetName() const override
Returns name of object.
Definition TNamed.h:47
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:48
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition TObject.cxx:973
virtual void AppendPad(Option_t *option="")
Append graphics object to current pad.
Definition TObject.cxx:184
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:780
@ kCanDelete
if object in a list can be deleted
Definition TObject.h:62
A Pave (see TPave) with text, lines or/and boxes inside.
Definition TPaveText.h:21
virtual TText * AddText(Double_t x1, Double_t y1, const char *label)
Add a new Text line to this pavetext at given coordinates.
void Draw(Option_t *option="") override
Draw this pavetext with its current attributes.
void Paint(Option_t *option="") override
Paint this pavetext with its current attributes.
virtual TText * GetLine(Int_t number) const
Get Pointer to line number in this pavetext.
virtual void SetName(const char *name="")
Definition TPave.h:79
virtual void SetBorderSize(Int_t bordersize=4)
Sets the border size of the TPave box and shadow.
Definition TPave.h:77
Double_t GetX1NDC() const
Definition TPave.h:59
virtual void SetX2NDC(Double_t x2)
Definition TPave.h:83
A slice of a piechart, see the TPie class.
Definition TPieSlice.h:18
void SetValue(Double_t)
Set the value for this slice.
Double_t GetRadiusOffset() const
return the value of the offset in radial direction for this slice.
Definition TPieSlice.cxx:72
void SetIsActive(Bool_t is)
Definition TPieSlice.h:40
void Copy(TObject &slice) const override
Copy TPieSlice.
Double_t GetValue() const
Return the value of this slice.
Definition TPieSlice.cxx:80
void SavePrimitive(std::ostream &out, Option_t *opts="") override
Save as C++ macro, used directly from TPie.
Definition TPieSlice.cxx:88
void SetRadiusOffset(Double_t)
Set the radial offset of this slice.
Draw a Pie Chart,.
Definition TPie.h:23
void SetEntryVal(Int_t, Double_t)
Set the value of a slice.
Definition TPie.cxx:1250
TPieSlice * GetSlice(Int_t i)
Return the reference to the slice of index 'id'.
Definition TPie.cxx:714
Float_t fLabelsOffset
LabelsOffset offset of label.
Definition TPie.h:37
void SetAngularOffset(Double_t)
Set the global angular offset for slices in degree [0,360].
Definition TPie.cxx:1165
void Paint(Option_t *) override
Paint a Pie chart in a canvas.
Definition TPie.cxx:804
Double_t GetEntryVal(Int_t)
Return the value associated with the slice number "i".
Definition TPie.cxx:696
TString fLabelFormat
Format format of the slices' label.
Definition TPie.h:38
Float_t * fSlices
!Subdivisions of the slices
Definition TPie.h:29
void SetX(Double_t)
Set X value.
Definition TPie.cxx:1363
Double_t fAngularOffset
Offset angular offset for the first slice.
Definition TPie.h:36
void SortSlices(Bool_t amode=kTRUE, Float_t merge_thresold=.0)
This method, mainly intended for internal use, ordered the slices according their values.
Definition TPie.cxx:1415
void SetEntryFillStyle(Int_t, Int_t)
Set the fill style for the "i" slice.
Definition TPie.cxx:1234
TPie()
Default constructor.
Definition TPie.cxx:64
~TPie() override
Destructor.
Definition TPie.cxx:156
void SetFractionFormat(const char *)
Set numeric format in the label, is used if the label format there is the modifier frac,...
Definition TPie.cxx:1308
Float_t fAngle3D
The angle of the pseudo-3d view.
Definition TPie.h:46
Double_t fHeight
Height of the slice in pixel.
Definition TPie.h:45
const char * GetPercentFormat()
Definition TPie.h:77
static TClass * Class()
void SetPercentFormat(const char *)
Set the numeric format for the percent value of a slice, default: %3.1f.
Definition TPie.cxx:1333
void SetLabels(const char *[])
Set the labels for all the slices.
Definition TPie.cxx:1316
void SetY(Double_t)
Set Y value.
Definition TPie.cxx:1371
TLegend * GetLegend()
If created before by Paint option or by MakeLegend method return the pointer to the legend,...
Definition TPie.cxx:705
Bool_t fIs3D
! true if the pseudo-3d is enabled
Definition TPie.h:44
void Init(Int_t np, Double_t ao, Double_t x, Double_t y, Double_t r)
Common initialization for all constructors.
Definition TPie.cxx:723
Int_t GetEntryFillColor(Int_t)
Return the color of the slice number "i".
Definition TPie.cxx:648
void SetLabelsOffset(Float_t)
Set the distance between the label end the external line of the TPie.
Definition TPie.cxx:1325
void SetEntryRadiusOffset(Int_t, Double_t)
Set the distance, in the direction of the radius of the slice.
Definition TPie.cxx:1242
Double_t GetAngularOffset()
Definition TPie.h:62
void DrawGhost()
This method is for internal use.
Definition TPie.cxx:300
Float_t GetLabelsOffset()
Definition TPie.h:74
TLegend * fLegend
!Legend for this piechart
Definition TPie.h:30
void SetLabelFormat(const char *)
This method is used to customize the label format.
Definition TPie.cxx:1288
Double_t fRadius
Radius Pie radius.
Definition TPie.h:35
TPieSlice ** fPieSlices
[fNvals] Slice array of this pie-chart
Definition TPie.h:43
void ExecuteEvent(Int_t, Int_t, Int_t) override
Execute the mouse events.
Definition TPie.cxx:396
Int_t DistancetoPrimitive(Int_t px, Int_t py) override
Evaluate the distance to the chart in gPad.
Definition TPie.cxx:170
void SetEntryLineStyle(Int_t, Int_t)
Set the style for the slice's outline. "i" is the slice number.
Definition TPie.cxx:1210
void MakeSlices(Bool_t force=kFALSE)
Make the slices.
Definition TPie.cxx:1380
void SetEntryFillColor(Int_t, Int_t)
Set the color for the slice "i".
Definition TPie.cxx:1226
void SetEntryLineWidth(Int_t, Int_t)
Set the width of the slice's outline. "i" is the slice number.
Definition TPie.cxx:1218
const char * GetLabelFormat()
Definition TPie.h:73
void SetCircle(Double_t x=.5, Double_t y=.5, Double_t rad=.4)
Set the coordinates of the circle that describe the pie:
Definition TPie.cxx:1182
const char * GetEntryLabel(Int_t)
Returns the label of the entry number "i".
Definition TPie.cxx:640
TString fValueFormat
Vform numeric format for the value.
Definition TPie.h:39
TString fFractionFormat
Rform numeric format for the fraction of a slice.
Definition TPie.h:40
void SetAngle3D(Float_t val=30.)
Set the value of for the pseudo 3D view angle, in degree.
Definition TPie.cxx:1152
Double_t GetEntryRadiusOffset(Int_t)
Return the radial offset's value for the slice number "i".
Definition TPie.cxx:688
Int_t GetEntryFillStyle(Int_t)
Return the style use to fill the slice number "i".
Definition TPie.cxx:656
const char * GetValueFormat()
Definition TPie.h:80
void SetRadius(Double_t)
Set the pie chart's radius' value.
Definition TPie.cxx:1341
void SavePrimitive(std::ostream &out, Option_t *opts="") override
Save primitive as a C++ statement(s) on output stream out.
Definition TPie.cxx:1120
TString fPercentFormat
Pfrom numeric format for the percent of a slice.
Definition TPie.h:41
TLegend * MakeLegend(Double_t x1=.65, Double_t y1=.65, Double_t x2=.95, Double_t y2=.95, const char *leg_header="")
This method create a legend that explains the contents of the slice for this pie-chart.
Definition TPie.cxx:770
Int_t fNvals
Number of elements.
Definition TPie.h:42
Int_t DistancetoSlice(Int_t, Int_t)
Returns the slice number at the pixel position (px,py).
Definition TPie.cxx:190
Int_t GetEntryLineStyle(Int_t)
Return the style used to outline thi "i" slice.
Definition TPie.cxx:672
Float_t fSum
!Sum for the slice values
Definition TPie.h:28
Double_t fY
Y coordinate of the pie centre.
Definition TPie.h:34
void SetEntryLabel(Int_t, const char *text="Slice")
Set slice number "i" label.
Definition TPie.cxx:1193
Double_t fX
X coordinate of the pie centre.
Definition TPie.h:33
void SetHeight(Double_t val=.08)
Set the height, in pixel, for the piechart if is drawn using the pseudo-3d mode.
Definition TPie.cxx:1272
Int_t GetEntryLineWidth(Int_t)
Return the line width used to outline thi "i" slice.
Definition TPie.cxx:680
Int_t GetEntryLineColor(Int_t)
Return the line color used to outline thi "i" slice.
Definition TPie.cxx:664
void Draw(Option_t *option="l") override
Draw the pie chart.
Definition TPie.cxx:277
void SetValueFormat(const char *)
Set the numeric format the slices' values.
Definition TPie.cxx:1355
void SetEntryLineColor(Int_t, Int_t)
Set the color for the slice's outline. "i" is the slice number.
Definition TPie.cxx:1202
void SetFillColors(Int_t *)
Set the fill colors for all the TPie's slices.
Definition TPie.cxx:1260
Basic string class.
Definition TString.h:139
Ssiz_t Length() const
Definition TString.h:417
void ToLower()
Change string to lower-case.
Definition TString.cxx:1182
void Clear()
Clear string without changing its capacity.
Definition TString.cxx:1235
const char * Data() const
Definition TString.h:376
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition TString.h:704
TString & Remove(Ssiz_t pos)
Definition TString.h:685
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition TString.cxx:2378
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition TString.h:632
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition TString.h:651
Float_t GetTitleX() const
Definition TStyle.h:280
Int_t GetOptTitle() const
Definition TStyle.h:246
Float_t GetTitleY() const
Definition TStyle.h:281
Style_t GetTitleFont(Option_t *axis="X") const
Return title font.
Definition TStyle.cxx:1216
Color_t GetTitleFillColor() const
Definition TStyle.h:271
Style_t GetTitleStyle() const
Definition TStyle.h:273
Float_t GetLabelOffset(Option_t *axis="X") const
Return label offset.
Definition TStyle.cxx:1133
Width_t GetTitleBorderSize() const
Definition TStyle.h:275
Int_t GetColorPalette(Int_t i) const
Return color number i in current palette.
Definition TStyle.cxx:1101
Color_t GetTitleTextColor() const
Definition TStyle.h:272
Float_t GetTitleH() const
Definition TStyle.h:283
Float_t GetTitleFontSize() const
Definition TStyle.h:274
Int_t GetTitleAlign() const
Definition TStyle.h:270
Float_t GetTitleW() const
Definition TStyle.h:282
Base class for several text objects.
Definition TText.h:22
TLine * line
Double_t y[n]
Definition legend1.C:17
Double_t x[n]
Definition legend1.C:17
Short_t Max(Short_t a, Short_t b)
Returns the largest of a and b.
Definition TMathBase.h:250
constexpr Double_t PiOver2()
Definition TMath.h:51
Double_t ATan2(Double_t y, Double_t x)
Returns the principal value of the arc tangent of y/x, expressed in radians.
Definition TMath.h:646
Double_t Sqrt(Double_t x)
Returns the square root of x.
Definition TMath.h:662
Short_t Min(Short_t a, Short_t b)
Returns the smallest of a and b.
Definition TMathBase.h:198
constexpr Double_t PiOver4()
Definition TMath.h:58
Double_t Cos(Double_t)
Returns the cosine of an angle of x radians.
Definition TMath.h:594
constexpr Double_t Pi()
Definition TMath.h:37
Double_t Sin(Double_t)
Returns the sine of an angle of x radians.
Definition TMath.h:588
Short_t Abs(Short_t d)
Returns the absolute value of parameter Short_t d.
Definition TMathBase.h:123
constexpr Double_t TwoPi()
Definition TMath.h:44
TLine l
Definition textangle.C:4