Logo ROOT  
Reference Guide
TPaletteAxis.cxx
Go to the documentation of this file.
1// @(#)root/histpainter:$Id$
2// Author: Rene Brun 15/11/2002
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 "TROOT.h"
13#include "TPaletteAxis.h"
14#include "TVirtualPad.h"
15#include "TVirtualX.h"
16#include "TStyle.h"
17#include "TMath.h"
18#include "TView.h"
19#include "TH1.h"
20#include "TGaxis.h"
21#include "TLatex.h"
22#include "snprintf.h"
23
24#include <iostream>
25
27
28
29////////////////////////////////////////////////////////////////////////////////
30
31/*! \class TPaletteAxis
32 \ingroup Histpainter
33 \brief The palette painting class.
34
35A `TPaletteAxis` object is used to display the color palette when
36drawing 2-d histograms.
37
38The `TPaletteAxis` is automatically created drawn when drawing a 2-D
39histogram when the option "Z" is specified.
40
41A `TPaletteAxis` object is added to the histogram list of functions and
42can be retrieved doing:
43
44 TPaletteAxis *palette = (TPaletteAxis*)h->GetListOfFunctions()->FindObject("palette");
45
46then the pointer `palette` can be used to change the palette attributes.
47
48Because the palette is created at painting time only, one must issue a:
49
50 gPad->Update();
51
52before retrieving the palette pointer in order to create the palette. The following
53macro gives an example.
54
55Begin_Macro(source)
56{
57 TCanvas *c1 = new TCanvas("c1","c1",600,400);
58 TH2F *h2 = new TH2F("h2","Example of a resized palette ",40,-4,4,40,-20,20);
59 Float_t px, py;
60 for (Int_t i = 0; i < 25000; i++) {
61 gRandom->Rannor(px,py);
62 h2->Fill(px,5*py);
63 }
64 gStyle->SetPalette(1);
65 h2->Draw("COLZ");
66 gPad->Update();
67 TPaletteAxis *palette = (TPaletteAxis*)h2->GetListOfFunctions()->FindObject("palette");
68 palette->SetY2NDC(0.7);
69 return c1;
70}
71End_Macro
72
73`TPaletteAxis` inherits from `TBox` and `TPave`. The methods
74allowing to specify the palette position are inherited from these two classes.
75
76The palette can be interactively moved and resized. The context menu
77can be used to set the axis attributes.
78
79It is possible to select a range on the axis to set the min/max in z
80
81As default labels and ticks are drawn by `TGAxis` at equidistant (lin or log)
82points as controlled by SetNdivisions.
83If option "CJUST" is given labels and ticks are justified at the
84color boundaries defined by the contour levels.
85In this case no optimization can be done. It is responsibility of the
86user to adjust minimum, maximum of the histogram and/or the contour levels
87to get a reasonable look of the plot.
88Only overlap of the labels is avoided if too many contour levels are used.
89
90This option is especially useful with user defined contours.
91An example is shown here:
92
93Begin_Macro(source)
94{
95 gStyle->SetOptStat(0);
96 TCanvas *c1 = new TCanvas("c1","exa_CJUST",300,10,400,400);
97 TH2F *hpxpy = new TH2F("hpxpy","py vs px",40,-4,4,40,-4,4);
98 // Fill histograms randomly
99 TRandom3 randomNum;
100 Float_t px, py;
101 for (Int_t i = 0; i < 25000; i++) {
102 randomNum.Rannor(px,py);
103 hpxpy->Fill(px,py);
104 }
105 hpxpy->SetMaximum(200);
106 Double_t zcontours[5] = {0, 20, 40, 80, 120};
107 hpxpy->SetContour(5, zcontours);
108 hpxpy->GetZaxis()->SetTickSize(0.01);
109 hpxpy->GetZaxis()->SetLabelOffset(0.01);
110 gPad->SetRightMargin(0.13);
111 hpxpy->SetTitle("User contours, CJUST");
112 hpxpy->Draw("COL Z CJUST");
113}
114End_Macro
115*/
116
117
118////////////////////////////////////////////////////////////////////////////////
119/// Palette default constructor.
120
122{
123 fH = nullptr;
124 SetName("");
125}
126
127
128////////////////////////////////////////////////////////////////////////////////
129/// Palette normal constructor.
130
132 : TPave(x1, y1, x2, y2)
133{
134 fH = h;
135 SetName("palette");
136 TAxis *zaxis = fH->GetZaxis();
138 if (gPad->GetView()) SetBit(kHasView);
139}
140
141
142////////////////////////////////////////////////////////////////////////////////
143/// Palette destructor.
144
146{
147}
148
149
150////////////////////////////////////////////////////////////////////////////////
151/// Palette copy constructor.
152
154{
155 ((TPaletteAxis&)palette).Copy(*this);
156}
157
158
159////////////////////////////////////////////////////////////////////////////////
160/// Assignment operator.
161
163{
164 orig.Copy( *this );
165 return *this;
166}
167
168
169////////////////////////////////////////////////////////////////////////////////
170/// Copy a palette to a palette.
171
173{
174 TPave::Copy(obj);
175 ((TPaletteAxis&)obj).fH = fH;
176}
177
178
179////////////////////////////////////////////////////////////////////////////////
180/// Check if mouse on the axis region.
181
183{
184 Int_t plxmax = gPad->XtoAbsPixel(fX2);
185 Int_t plymin = gPad->YtoAbsPixel(fY1);
186 Int_t plymax = gPad->YtoAbsPixel(fY2);
187 if (px > plxmax && px < plxmax + 30 && py >= plymax && py <= plymin) return px - plxmax;
188
189 //otherwise check if inside the box
190 return TPave::DistancetoPrimitive(px, py);
191}
192
193
194////////////////////////////////////////////////////////////////////////////////
195/// Check if mouse on the axis region.
196
198{
199 if (!gPad) return;
200
201 static Int_t kmode = 0;
202 Int_t plxmin = gPad->XtoAbsPixel(fX1);
203 Int_t plxmax = gPad->XtoAbsPixel(fX2);
204 if (kmode != 0 || px <= plxmax) {
205 if (event == kButton1Down) kmode = 1;
206 TBox::ExecuteEvent(event, px, py);
207 if (event == kButton1Up) kmode = 0;
208 // In case palette coordinates have been modified, recompute NDC coordinates
209 Double_t dpx = gPad->GetX2() - gPad->GetX1();
210 Double_t dpy = gPad->GetY2() - gPad->GetY1();
211 Double_t xp1 = gPad->GetX1();
212 Double_t yp1 = gPad->GetY1();
213 fX1NDC = (fX1 - xp1) / dpx;
214 fY1NDC = (fY1 - yp1) / dpy;
215 fX2NDC = (fX2 - xp1) / dpx;
216 fY2NDC = (fY2 - yp1) / dpy;
217 return;
218 }
219 gPad->SetCursor(kHand);
220 static Double_t ratio1, ratio2;
221 static Int_t px1old, py1old, px2old, py2old;
222 Double_t temp, xmin, xmax;
223
224 switch (event) {
225
226 case kButton1Down:
227 ratio1 = (gPad->AbsPixeltoY(py) - fY1) / (fY2 - fY1);
228 py1old = gPad->YtoAbsPixel(fY1 + ratio1 * (fY2 - fY1));
229 px1old = plxmin;
230 px2old = plxmax;
231 py2old = py1old;
232 gVirtualX->DrawBox(px1old, py1old, px2old, py2old, TVirtualX::kHollow);
233 gVirtualX->SetLineColor(-1);
234 // No break !!!
235
236 case kButton1Motion:
237 gVirtualX->DrawBox(px1old, py1old, px2old, py2old, TVirtualX::kHollow);
238 ratio2 = (gPad->AbsPixeltoY(py) - fY1) / (fY2 - fY1);
239 py2old = gPad->YtoAbsPixel(fY1 + ratio2 * (fY2 - fY1));
240 gVirtualX->DrawBox(px1old, py1old, px2old, py2old, TVirtualX::kHollow);
241 break;
242
243 case kButton1Up:
244 if (gROOT->IsEscaped()) {
245 gROOT->SetEscape(kFALSE);
246 break;
247 }
248
249 ratio2 = (gPad->AbsPixeltoY(py) - fY1) / (fY2 - fY1);
250 xmin = ratio1;
251 xmax = ratio2;
252 if (xmin > xmax) {
253 temp = xmin;
254 xmin = xmax;
255 xmax = temp;
256 temp = ratio1;
257 ratio1 = ratio2;
258 ratio2 = temp;
259 }
260 if (ratio2 - ratio1 > 0.05) {
261 if (fH->GetDimension() == 2) {
262 Double_t zmin = fH->GetMinimum();
263 Double_t zmax = fH->GetMaximum();
264 if (gPad->GetLogz()) {
265 if (zmin <= 0 && zmax > 0) zmin = TMath::Min((Double_t)1,
266 (Double_t)0.001 * zmax);
267 zmin = TMath::Log10(zmin);
268 zmax = TMath::Log10(zmax);
269 }
270 Double_t newmin = zmin + (zmax - zmin) * ratio1;
271 Double_t newmax = zmin + (zmax - zmin) * ratio2;
272 if (newmin < zmin)newmin = fH->GetBinContent(fH->GetMinimumBin());
273 if (newmax > zmax)newmax = fH->GetBinContent(fH->GetMaximumBin());
274 if (gPad->GetLogz()) {
275 newmin = TMath::Exp(2.302585092994 * newmin);
276 newmax = TMath::Exp(2.302585092994 * newmax);
277 }
278 fH->SetMinimum(newmin);
279 fH->SetMaximum(newmax);
281 }
282 gPad->Modified(kTRUE);
283 }
284 gVirtualX->SetLineColor(-1);
285 kmode = 0;
286 break;
287 }
288}
289
290
291////////////////////////////////////////////////////////////////////////////////
292/// Returns the color index of the bin (i,j).
293///
294/// This function should be used after an histogram has been plotted with the
295/// option COL or COLZ like in the following example:
296///
297/// h2->Draw("COLZ");
298/// gPad->Update();
299/// TPaletteAxis *palette = (TPaletteAxis*)h2->GetListOfFunctions()->FindObject("palette");
300/// Int_t ci = palette->GetBinColor(20,15);
301///
302/// Then it is possible to retrieve the RGB components in the following way:
303///
304/// TColor *c = gROOT->GetColor(ci);
305/// float x,y,z;
306/// c->GetRGB(x,y,z);
307
309{
310 Double_t zc = fH->GetBinContent(i, j);
311 return GetValueColor(zc);
312}
313
314
315////////////////////////////////////////////////////////////////////////////////
316/// Displays the z value corresponding to cursor position py.
317
318char *TPaletteAxis::GetObjectInfo(Int_t /* px */, Int_t py) const
319{
320 Double_t z;
321 static char info[64];
322
323 Double_t zmin = fH->GetMinimum();
324 Double_t zmax = fH->GetMaximum();
325 Int_t y1 = gPad->GetWh() - gPad->VtoPixel(fY1NDC);
326 Int_t y2 = gPad->GetWh() - gPad->VtoPixel(fY2NDC);
327 Int_t y = gPad->GetWh() - py;
328
329 if (gPad->GetLogz()) {
330 if (zmin <= 0 && zmax > 0) zmin = TMath::Min((Double_t)1,
331 (Double_t)0.001 * zmax);
332 Double_t zminl = TMath::Log10(zmin);
333 Double_t zmaxl = TMath::Log10(zmax);
334 Double_t zl = (zmaxl - zminl) * ((Double_t)(y - y1) / (Double_t)(y2 - y1)) + zminl;
335 z = TMath::Power(10., zl);
336 } else {
337 z = (zmax - zmin) * ((Double_t)(y - y1) / (Double_t)(y2 - y1)) + zmin;
338 }
339
340 snprintf(info, 64, "(z=%g)", z);
341 return info;
342}
343
344
345////////////////////////////////////////////////////////////////////////////////
346/// Returns the color index of the given z value
347///
348/// This function should be used after an histogram has been plotted with the
349/// option COL or COLZ like in the following example:
350///
351/// h2->Draw("COLZ");
352/// gPad->Update();
353/// TPaletteAxis *palette = (TPaletteAxis*)h2->GetListOfFunctions()->FindObject("palette");
354/// Int_t ci = palette->GetValueColor(30.);
355///
356/// Then it is possible to retrieve the RGB components in the following way:
357///
358/// TColor *c = gROOT->GetColor(ci);
359/// float x,y,z;
360/// c->GetRGB(x,y,z);
361
363{
366 Double_t wlmin = wmin;
367 Double_t wlmax = wmax;
368
369 if (gPad->GetLogz()) {
370 if (wmin <= 0 && wmax > 0) wmin = TMath::Min((Double_t)1,
371 (Double_t)0.001 * wmax);
372 wlmin = TMath::Log10(wmin);
373 wlmax = TMath::Log10(wmax);
374 }
375
376 Int_t ncolors = gStyle->GetNumberOfColors();
377 Int_t ndivz = fH->GetContour();
378 if (ndivz == 0) return 0;
379 ndivz = TMath::Abs(ndivz);
380 Int_t theColor, color;
381 Double_t scale = ndivz / (wlmax - wlmin);
382
383 if (fH->TestBit(TH1::kUserContour) && gPad->GetLogz()) zc = TMath::Log10(zc);
384 if (zc < wlmin) zc = wlmin;
385
386 color = Int_t(0.01 + (zc - wlmin) * scale);
387
388 theColor = Int_t((color + 0.99) * Double_t(ncolors) / Double_t(ndivz));
389 return gStyle->GetColorPalette(theColor);
390}
391
392
393////////////////////////////////////////////////////////////////////////////////
394/// Paint the palette.
395
397{
399
400 SetFillStyle(1001);
401 Double_t ymin = fY1;
402 Double_t ymax = fY2;
403 Double_t xmin = fX1;
404 Double_t xmax = fX2;
407 Double_t wlmin = wmin;
408 Double_t wlmax = wmax;
409 Double_t b1, b2, w1, w2, zc;
410 Bool_t kHorizontal = false;
411
412 if ((wlmax - wlmin) <= 0) {
413 Double_t mz = wlmin * 0.1;
414 if (mz == 0) mz = 0.1;
415 wlmin = wlmin - mz;
416 wlmax = wlmax + mz;
417 wmin = wlmin;
418 wmax = wlmax;
419 }
420
421 if (GetX2NDC()-GetX1NDC() > GetY2NDC()-GetY1NDC()) kHorizontal = true;
422
423 if (gPad->GetLogz()) {
424 if (wmin <= 0 && wmax > 0) wmin = TMath::Min((Double_t)1, (Double_t)0.001 * wmax);
425 wlmin = TMath::Log10(wmin);
426 wlmax = TMath::Log10(wmax);
427 }
428 Double_t ws = wlmax - wlmin;
429 Int_t ncolors = gStyle->GetNumberOfColors();
430 Int_t ndivz = fH->GetContour();
431 if (ndivz == 0) return;
432 ndivz = TMath::Abs(ndivz);
433 Int_t theColor, color;
434 // import Attributes already here since we might need them for CJUST
436 // case option "CJUST": put labels directly at color boundaries
437 TLatex *label = nullptr;
438 TLine *line = nullptr;
439 Double_t prevlab = 0;
440 TString opt(fH->GetDrawOption());
441 if (opt.Contains("CJUST", TString::kIgnoreCase)) {
442 label = new TLatex();
445 if (kHorizontal) label->SetTextAlign(kHAlignCenter+kVAlignTop);
447 line = new TLine();
449 if (kHorizontal) line->PaintLine(xmin, ymin, xmax, ymin);
450 else line->PaintLine(xmax, ymin, xmax, ymax);
451 }
452 Double_t scale = ndivz / (wlmax - wlmin);
453 for (Int_t i = 0; i < ndivz; i++) {
454
455 zc = fH->GetContourLevel(i);
456 if (fH->TestBit(TH1::kUserContour) && gPad->GetLogz())
457 zc = TMath::Log10(zc);
458 w1 = zc;
459 if (w1 < wlmin) w1 = wlmin;
460
461 w2 = wlmax;
462 if (i < ndivz - 1) {
463 zc = fH->GetContourLevel(i + 1);
464 if (fH->TestBit(TH1::kUserContour) && gPad->GetLogz())
465 zc = TMath::Log10(zc);
466 w2 = zc;
467 }
468
469 if (w2 <= wlmin) continue;
470 if (kHorizontal) {
471 b1 = xmin + (w1 - wlmin) * (xmax - xmin) / ws;
472 b2 = xmin + (w2 - wlmin) * (xmax - xmin) / ws;
473 } else {
474 b1 = ymin + (w1 - wlmin) * (ymax - ymin) / ws;
475 b2 = ymin + (w2 - wlmin) * (ymax - ymin) / ws;
476 }
477
479 color = i;
480 } else {
481 color = Int_t(0.01 + (w1 - wlmin) * scale);
482 }
483
484 theColor = Int_t((color + 0.99) * Double_t(ncolors) / Double_t(ndivz));
487 if (kHorizontal) gPad->PaintBox(b1, ymin, b2, ymax);
488 else gPad->PaintBox(xmin, b1, xmax, b2);
489 // case option "CJUST": put labels directly
490 if (label) {
491 Double_t lof = fAxis.GetLabelOffset()*(gPad->GetUxmax()-gPad->GetUxmin());
492 // the following assumes option "S"
493 Double_t tlength = fAxis.GetTickSize() * (gPad->GetUxmax()-gPad->GetUxmin());
494 Double_t lsize = fAxis.GetLabelSize();
495 Double_t lsize_user = lsize*(gPad->GetUymax()-gPad->GetUymin());
496 Double_t zlab = fH->GetContourLevel(i);
497 if (gPad->GetLogz()&& !fH->TestBit(TH1::kUserContour)) {
498 zlab = TMath::Power(10, zlab);
499 }
500 // make sure labels dont overlap
501 if (i == 0 || (b1 - prevlab) > 1.5*lsize_user) {
502 if (kHorizontal) label->PaintLatex(b1, ymin - lof, 0, lsize, Form("%g", zlab));
503 else label->PaintLatex(xmax + lof, b1, 0, lsize, Form("%g", zlab));
504 prevlab = b1;
505 }
506 if (kHorizontal) line->PaintLine(b2, ymin+tlength, b2, ymin);
507 else line->PaintLine(xmax-tlength, b1, xmax, b1);
508 if (i == ndivz-1) {
509 // label + tick at top of axis
510 if ((b2 - prevlab > 1.5*lsize_user)) {
511 if (kHorizontal) label->PaintLatex(b2, ymin - lof, 0, lsize, Form("%g",fH->GetMaximum()));
512 else label->PaintLatex(xmax + lof, b2, 0, lsize, Form("%g",fH->GetMaximum()));
513 }
514 if (kHorizontal) line->PaintLine(b1, ymin+tlength, b1, ymin);
515 else line->PaintLine(xmax-tlength, b2, xmax, b2);
516 }
517 }
518 }
519
520 // Take primary divisions only
521 Int_t ndiv = fH->GetZaxis()->GetNdivisions();
522 Bool_t isOptimized = ndiv>0;
523 Int_t absDiv = abs(ndiv);
524 Int_t maxD = absDiv/1000000;
525 ndiv = absDiv%100 + maxD*1000000;
526 if (!isOptimized) ndiv = -ndiv;
527
528 char chopt[6] = "S ";
529 chopt[1] = 0;
530 strncat(chopt, "+L", 3);
531 if (ndiv < 0) {
532 ndiv = TMath::Abs(ndiv);
533 strncat(chopt, "N", 2);
534 }
535 if (gPad->GetLogz()) {
536 wmin = TMath::Power(10., wlmin);
537 wmax = TMath::Power(10., wlmax);
538 strncat(chopt, "G", 2);
539 }
540 if (label) {
541 // case option "CJUST", cleanup
542 delete label;
543 delete line;
544 } else {
545 // default
546 if (kHorizontal) fAxis.PaintAxis(xmin, ymin, xmax, ymin, wmin, wmax, ndiv, chopt);
547 else fAxis.PaintAxis(xmax, ymin, xmax, ymax, wmin, wmax, ndiv, chopt);
548 }
549}
550
551
552////////////////////////////////////////////////////////////////////////////////
553/// Save primitive as a C++ statement(s) on output stream out.
554
555void TPaletteAxis::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
556{
557 //char quote = '"';
558 out << " " << std::endl;
559 if (gROOT->ClassSaved(TPaletteAxis::Class())) {
560 out << " ";
561 } else {
562 out << " " << ClassName() << " *";
563 }
564 if (fOption.Contains("NDC")) {
565 out << "palette = new " << ClassName() << "(" << fX1NDC << "," << fY1NDC << "," << fX2NDC << "," << fY2NDC
566 << "," << fH->GetName() << ");" << std::endl;
567 } else {
568 out << "palette = new " << ClassName() << "(" << fX1 << "," << fY1 << "," << fX2 << "," << fY2
569 << "," << fH->GetName() << ");" << std::endl;
570 }
571 out << " palette->SetLabelColor(" << fAxis.GetLabelColor() << ");" << std::endl;
572 out << " palette->SetLabelFont(" << fAxis.GetLabelFont() << ");" << std::endl;
573 out << " palette->SetLabelOffset(" << fAxis.GetLabelOffset() << ");" << std::endl;
574 out << " palette->SetLabelSize(" << fAxis.GetLabelSize() << ");" << std::endl;
575 out << " palette->SetTitleOffset(" << fAxis.GetTitleOffset() << ");" << std::endl;
576 out << " palette->SetTitleSize(" << fAxis.GetTitleSize() << ");" << std::endl;
577 SaveFillAttributes(out, "palette", -1, -1);
578 SaveLineAttributes(out, "palette", 1, 1, 1);
579}
580
581
582////////////////////////////////////////////////////////////////////////////////
583/// Unzoom the palette
584
586{
587 TView *view = gPad ? gPad->GetView() : nullptr;
588 if (view) {
589 delete view;
590 gPad->SetView(nullptr);
591 }
592 fH->GetZaxis()->SetRange(0, 0);
593 if (fH->GetDimension() == 2) {
594 fH->SetMinimum();
595 fH->SetMaximum();
597 }
598}
@ kButton1Motion
Definition: Buttons.h:20
@ kButton1Up
Definition: Buttons.h:19
@ kButton1Down
Definition: Buttons.h:17
@ kHand
Definition: GuiTypes.h:374
#define h(i)
Definition: RSha256.hxx:106
int Int_t
Definition: RtypesCore.h:45
const Bool_t kFALSE
Definition: RtypesCore.h:101
double Double_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:100
const char Option_t
Definition: RtypesCore.h:66
#define ClassImp(name)
Definition: Rtypes.h:375
@ kVAlignTop
Definition: TAttText.h:54
@ kVAlignCenter
Definition: TAttText.h:54
@ kHAlignLeft
Definition: TAttText.h:53
@ kHAlignCenter
Definition: TAttText.h:53
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t wmin
Option_t Option_t TPoint TPoint const char x2
Option_t Option_t TPoint TPoint const char x1
Option_t Option_t TPoint TPoint const char y2
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t wmax
Option_t Option_t TPoint TPoint const char y1
float xmin
Definition: THbookFile.cxx:95
float ymin
Definition: THbookFile.cxx:95
float xmax
Definition: THbookFile.cxx:95
float ymax
Definition: THbookFile.cxx:95
#define gROOT
Definition: TROOT.h:404
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition: TString.cxx:2447
R__EXTERN TStyle * gStyle
Definition: TStyle.h:414
#define gPad
Definition: TVirtualPad.h:288
#define gVirtualX
Definition: TVirtualX.h:338
#define snprintf
Definition: civetweb.c:1540
virtual Int_t GetNdivisions() const
Definition: TAttAxis.h:36
virtual void Modify()
Change current fill area attributes if necessary.
Definition: TAttFill.cxx:213
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 void SaveFillAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1001)
Save fill attributes as C++ statement(s) on output stream out.
Definition: TAttFill.cxx:236
virtual Color_t GetLineColor() const
Return the line color.
Definition: TAttLine.h:33
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition: TAttLine.h:40
virtual void SaveLineAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t widdef=1)
Save line attributes as C++ statement(s) on output stream out.
Definition: TAttLine.cxx:273
virtual void SetTextAlign(Short_t align=11)
Set the text alignment.
Definition: TAttText.h:42
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
Class to manage histogram axis.
Definition: TAxis.h:30
virtual void SetRange(Int_t first=0, Int_t last=0)
Set the viewing range for the axis using bin numbers.
Definition: TAxis.cxx:953
Double_t fX1
X of 1st point.
Definition: TBox.h:28
void ExecuteEvent(Int_t event, Int_t px, Int_t py) override
Execute action corresponding to one event.
Definition: TBox.cxx:231
Double_t fY2
Y of 2nd point.
Definition: TBox.h:31
Double_t fX2
X of 2nd point.
Definition: TBox.h:30
Double_t fY1
Y of 1st point.
Definition: TBox.h:29
virtual void PaintAxis(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax, Double_t &wmin, Double_t &wmax, Int_t &ndiv, Option_t *chopt="", Double_t gridlength=0, Bool_t drawGridOnly=kFALSE)
Control function to draw an axis.
Definition: TGaxis.cxx:976
Float_t GetLabelOffset() const
Definition: TGaxis.h:80
virtual void ImportAxisAttributes(TAxis *axis)
Internal method to import TAxis attributes to this TGaxis.
Definition: TGaxis.cxx:926
Int_t GetLabelFont() const
Definition: TGaxis.h:79
Float_t GetTitleOffset() const
Definition: TGaxis.h:82
Float_t GetTitleSize() const
Definition: TGaxis.h:83
Int_t GetLabelColor() const
Definition: TGaxis.h:78
Float_t GetTickSize() const
Definition: TGaxis.h:91
Float_t GetLabelSize() const
Definition: TGaxis.h:81
TH1 is the base class of all histogram classes in ROOT.
Definition: TH1.h:58
TAxis * GetZaxis()
Definition: TH1.h:321
virtual Int_t GetDimension() const
Definition: TH1.h:281
@ kUserContour
User specified contour levels.
Definition: TH1.h:164
@ kIsZoomed
Bit set when zooming on Y axis.
Definition: TH1.h:167
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:8420
virtual void SetMaximum(Double_t maximum=-1111)
Definition: TH1.h:397
virtual void SetMinimum(Double_t minimum=-1111)
Definition: TH1.h:398
virtual Int_t GetMaximumBin() const
Return location of bin with maximum value in the range.
Definition: TH1.cxx:8452
virtual Double_t GetBinContent(Int_t bin) const
Return content of bin number bin.
Definition: TH1.cxx:5035
virtual Int_t GetContour(Double_t *levels=nullptr)
Return contour values into array levels if pointer levels is non zero.
Definition: TH1.cxx:8286
virtual Double_t GetContourLevel(Int_t level) const
Return value of contour number level.
Definition: TH1.cxx:8305
virtual Int_t GetMinimumBin() const
Return location of bin with minimum value in the range.
Definition: TH1.cxx:8540
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:8510
To draw Mathematical Formula.
Definition: TLatex.h:18
virtual void PaintLatex(Double_t x, Double_t y, Double_t angle, Double_t size, const char *text)
Main drawing function.
Definition: TLatex.cxx:2066
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:397
const char * GetName() const override
Returns name of object.
Definition: TNamed.h:47
Mother of all ROOT objects.
Definition: TObject.h:37
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:187
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition: TObject.cxx:130
virtual Option_t * GetDrawOption() const
Get option used by the graphics system to draw this object.
Definition: TObject.cxx:343
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:696
void ResetBit(UInt_t f)
Definition: TObject.h:186
The palette painting class.
Definition: TPaletteAxis.h:29
void SavePrimitive(std::ostream &out, Option_t *option="") override
Save primitive as a C++ statement(s) on output stream out.
Int_t DistancetoPrimitive(Int_t px, Int_t py) override
Check if mouse on the axis region.
void Paint(Option_t *option="") override
Paint the palette.
TGaxis fAxis
Palette axis.
Definition: TPaletteAxis.h:32
TPaletteAxis & operator=(const TPaletteAxis &)
Assignment operator.
~TPaletteAxis() override
Palette destructor.
char * GetObjectInfo(Int_t px, Int_t py) const override
Displays the z value corresponding to cursor position py.
TPaletteAxis()
Palette default constructor.
Int_t GetBinColor(Int_t i, Int_t j)
Returns the color index of the bin (i,j).
void Copy(TObject &palette) const override
Copy a palette to a palette.
TH1 * fH
! Pointer to parent histogram
Definition: TPaletteAxis.h:33
virtual void UnZoom()
Unzoom the palette.
void ExecuteEvent(Int_t event, Int_t px, Int_t py) override
Check if mouse on the axis region.
Int_t GetValueColor(Double_t zc)
Returns the color index of the given z value.
static TClass * Class()
A TBox with a bordersize and a shadow option.
Definition: TPave.h:19
Double_t GetY2NDC() const
Definition: TPave.h:62
virtual void ConvertNDCtoPad()
Convert pave coordinates from NDC to Pad coordinates.
Definition: TPave.cxx:139
Double_t GetX2NDC() const
Definition: TPave.h:60
void Copy(TObject &pave) const override
Copy this pave to pave.
Definition: TPave.cxx:186
virtual void SetName(const char *name="")
Definition: TPave.h:75
Double_t fX2NDC
X2 point in NDC coordinates.
Definition: TPave.h:24
Double_t GetY1NDC() const
Definition: TPave.h:61
TString fOption
Pave style.
Definition: TPave.h:30
Double_t fY2NDC
Y2 point in NDC coordinates.
Definition: TPave.h:25
Int_t DistancetoPrimitive(Int_t px, Int_t py) override
Compute distance from point px,py to a pave.
Definition: TPave.cxx:208
Double_t fX1NDC
X1 point in NDC coordinates.
Definition: TPave.h:22
Double_t fY1NDC
Y1 point in NDC coordinates.
Definition: TPave.h:23
Double_t GetX1NDC() const
Definition: TPave.h:59
Basic string class.
Definition: TString.h:136
@ kIgnoreCase
Definition: TString.h:268
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
Int_t GetColorPalette(Int_t i) const
Return color number i in current palette.
Definition: TStyle.cxx:1057
Int_t GetNumberOfColors() const
Return number of colors in the color palette.
Definition: TStyle.cxx:1123
See TView3D.
Definition: TView.h:25
TLine * line
RVec< PromoteType< T > > abs(const RVec< T > &v)
Definition: RVec.hxx:1739
Double_t y[n]
Definition: legend1.C:17
Double_t Exp(Double_t x)
Returns the base-e exponential function of x, which is e raised to the power x.
Definition: TMath.h:706
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Returns x raised to the power y.
Definition: TMath.h:718
Short_t Min(Short_t a, Short_t b)
Returns the smallest of a and b.
Definition: TMathBase.h:198
Double_t Log10(Double_t x)
Returns the common (base-10) logarithm of x.
Definition: TMath.h:759
Short_t Abs(Short_t d)
Returns the absolute value of parameter Short_t d.
Definition: TMathBase.h:123
void ws()
Definition: ws.C:66