Logo ROOT   6.14/05
Reference Guide
TGLTH3Composition.cxx
Go to the documentation of this file.
1 // @(#)root/gl:$Id$
2 // Author: Timur Pocheptsov 07/08/2009
3 
4 #include <stdexcept>
5 
6 #include "KeySymbols.h"
7 #include "TVirtualX.h"
8 #include "Buttons.h"
9 #include "TString.h"
10 #include "TError.h"
11 #include "TColor.h"
12 #include "TROOT.h"
13 #include "TMath.h"
14 
15 #include "TGLTH3Composition.h"
16 #include "TGLIncludes.h"
17 
18 /** \class TGLTH3Composition
19 \ingroup opengl
20 */
21 
23 
24 ////////////////////////////////////////////////////////////////////////////////
25 ///I have to define it, since explicit copy ctor was declared.
26 
28 {
29 }
30 
31 namespace {
32 
33 void CompareAxes(const TAxis *a1, const TAxis *a2, const TString &axisName);
34 
35 }
36 
37 ////////////////////////////////////////////////////////////////////////////////
38 ///Add TH3 into collection. Throw if fHists is not empty
39 ///but ranges are not equal.
40 
42 {
43  const TAxis *xa = h->GetXaxis();
44  const TAxis *ya = h->GetYaxis();
45  const TAxis *za = h->GetZaxis();
46 
47  if (!fHists.size()) {
48  //This is the first hist in a composition,
49  //take its ranges and reset axes for the composition.
50  fXaxis.Set(h->GetNbinsX(), xa->GetBinLowEdge(xa->GetFirst()), xa->GetBinUpEdge(xa->GetLast()));
51  fYaxis.Set(h->GetNbinsY(), ya->GetBinLowEdge(ya->GetFirst()), ya->GetBinUpEdge(ya->GetLast()));
52  fZaxis.Set(h->GetNbinsZ(), za->GetBinLowEdge(za->GetFirst()), za->GetBinUpEdge(za->GetLast()));
53  } else {
54  CompareAxes(xa, GetXaxis(), "X");
55  CompareAxes(ya, GetYaxis(), "Y");
56  CompareAxes(za, GetZaxis(), "Z");
57  }
58 
59  fHists.push_back(TH3Pair_t(h, shape));
60 }
61 
62 ////////////////////////////////////////////////////////////////////////////////
63 ///Check if "this" is under cursor.
64 
66 {
67  if (!fPainter.get())
68  return 9999;
69 
70  return fPainter->DistancetoPrimitive(px, py);
71 }
72 
73 ////////////////////////////////////////////////////////////////////////////////
74 ///Mouse and keyboard events.
75 
77 {
78  fPainter->ExecuteEvent(event, px, py);
79 }
80 
81 ////////////////////////////////////////////////////////////////////////////////
82 ///I cannot show bin content in a status bar -
83 ///since there can be several bins in one.
84 
85 char *TGLTH3Composition::GetObjectInfo(Int_t /*px*/, Int_t /*py*/) const
86 {
87  static char message[] = "TH3 composition";
88  return message;
89 }
90 
91 ////////////////////////////////////////////////////////////////////////////////
92 ///Paint a composition of 3d hists.
93 
95 {
96  if (!fHists.size())
97  return;
98 
99  //create a painter.
100  if (!fPainter.get())
101  fPainter.reset(new TGLHistPainter(this));
102 
103  fPainter->Paint("dummy");
104 }
105 
106 /** \class TGLTH3CompositionPainter
107 \ingroup opengl
108 */
109 
111 
112 ////////////////////////////////////////////////////////////////////////////////
113 ///Ctor.
114 
116  TGLPlotCoordinates *coord)
117  : TGLPlotPainter(data, cam, coord, kFALSE, kFALSE, kFALSE),
118  fData(data)
119 {
120 }
121 
122 ////////////////////////////////////////////////////////////////////////////////
123 ///Will be never called from TPad.
124 
126 {
127  static char message[] = "TH3 composition";
128  return message;
129 }
130 
131 ////////////////////////////////////////////////////////////////////////////////
132 
134 {
135  if (!fData->fHists.size())
136  return kFALSE;
137 
138  //Prepare plot painter.
139  //Forget about log scale.
143 
144  if (!fCoord->SetRanges(fHist, kFALSE, kTRUE))//kFALSE == drawErrors, kTRUE == zAsBins
145  return kFALSE;
146 
148  if (fCamera)
150 
151  //Loop on hists.
152  const TH3 *h = fData->fHists[0].first;
154  fCoord->GetFirstYBin(),
155  fCoord->GetFirstZBin());
156  fMinMaxVal.first = fMinMaxVal.second;
157 
158  for (UInt_t hNum = 0, lastH = fData->fHists.size(); hNum < lastH; ++hNum) {
159  h = fData->fHists[hNum].first;
160  for (Int_t ir = fCoord->GetFirstXBin(); ir <= fCoord->GetLastXBin(); ++ir) {
161  for (Int_t jr = fCoord->GetFirstYBin(); jr <= fCoord->GetLastYBin(); ++jr) {
162  for (Int_t kr = fCoord->GetFirstZBin(); kr <= fCoord->GetLastZBin(); ++kr) {
163  fMinMaxVal.second = TMath::Max(fMinMaxVal.second, h->GetBinContent(ir, jr, kr));
164  fMinMaxVal.first = TMath::Min(fMinMaxVal.first, h->GetBinContent(ir, jr, kr));
165  }
166  }
167  }
168  }
169 
170  if (fCoord->Modified()) {
173  }
174 
175  return kTRUE;
176 }
177 
178 ////////////////////////////////////////////////////////////////////////////////
179 ///Move plot or box cut.
180 
182 {
183  fMousePosition.fX = px;
185  fCamera->StartPan(px, py);
186  fBoxCut.StartMovement(px, fCamera->GetHeight() - py);
187 }
188 
189 ////////////////////////////////////////////////////////////////////////////////
190 /// User's moving mouse cursor, with middle mouse button pressed (for pad).
191 /// Calculate 3d shift related to 2d mouse movement.
192 
194 {
195  if (fSelectedPart >= fSelectionBase) {//Pan camera.
198 
199  fCamera->SetCamera();
201  fCamera->Pan(px, py);
202 
205  } else if (fSelectedPart > 0) {
206  //Convert py into bottom-top orientation.
207  //Possibly, move box here
208  py = fCamera->GetHeight() - py;
211 
212  fCamera->SetCamera();
214 
215  if (!fHighColor) {
217  fBoxCut.MoveBox(px, py, fSelectedPart);
218  }
219 
222  }
223 
224  fMousePosition.fX = px, fMousePosition.fY = py;
226 }
227 
228 ////////////////////////////////////////////////////////////////////////////////
229 ///No options for composition.
230 
232 {
233 }
234 
235 ////////////////////////////////////////////////////////////////////////////////
236 ///Switch on/off box cut.
237 
239 {
240  if (event == kButton1Double && fBoxCut.IsActive()) {
241  fBoxCut.TurnOnOff();
242  if (!gVirtualX->IsCmdThread())
243  gROOT->ProcessLineFast(Form("((TGLPlotPainter *)0x%lx)->Paint()", (ULong_t)this));
244  else
245  Paint();
246  } else if (event == kKeyPress && (py == kKey_c || py == kKey_C)) {
247  if (fHighColor)
248  Info("ProcessEvent", "Switch to true color mode to use box cut");
249  else {
250  fBoxCut.TurnOnOff();
252  }
253  }
254 }
255 
256 ////////////////////////////////////////////////////////////////////////////////
257 /// Initialize some gl state variables.
258 
260 {
261  glEnable(GL_DEPTH_TEST);
262  glEnable(GL_LIGHTING);
263  glEnable(GL_LIGHT0);
264  glEnable(GL_CULL_FACE);
265  glCullFace(GL_BACK);
266 
267  glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
268 }
269 
270 ////////////////////////////////////////////////////////////////////////////////
271 ///Return back some gl state variables.
272 
274 {
275  glDisable(GL_DEPTH_TEST);
276  glDisable(GL_LIGHTING);
277  glDisable(GL_LIGHT0);
278  glDisable(GL_CULL_FACE);
279  glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
280 }
281 
282 ////////////////////////////////////////////////////////////////////////////////
283 ///Draw composition of TH3s.
284 
286 {
287  //Shift plot to point of origin.
288  const Rgl::PlotTranslation trGuard(this);
289 
291 
292  if (!fSelectionPass) {
293  glEnable(GL_POLYGON_OFFSET_FILL);//[0
294  glPolygonOffset(1.f, 1.f);
295  } else
296  return;
297 
298  //Using front point, find the correct order to draw boxes from
299  //back to front/from bottom to top (it's important only for semi-transparent boxes).
300  const Int_t frontPoint = fBackBox.GetFrontPoint();
301  Int_t irInit = fCoord->GetFirstXBin(), iInit = 0;
302  const Int_t nX = fCoord->GetNXBins();
303  Int_t jrInit = fCoord->GetFirstYBin(), jInit = 0;
304  const Int_t nY = fCoord->GetNYBins();
305  Int_t krInit = fCoord->GetFirstZBin(), kInit = 0;
306  const Int_t nZ = fCoord->GetNZBins();
307 
308  const Int_t addI = frontPoint == 2 || frontPoint == 1 ? 1 : (iInit = nX - 1, irInit = fCoord->GetLastXBin(), -1);
309  const Int_t addJ = frontPoint == 2 || frontPoint == 3 ? 1 : (jInit = nY - 1, jrInit = fCoord->GetLastYBin(), -1);
310  const Int_t addK = fBackBox.Get2DBox()[frontPoint + 4].Y() < fBackBox.Get2DBox()[frontPoint].Y() ? 1
311  : (kInit = nZ - 1, krInit = fCoord->GetLastZBin(),-1);
312  const Double_t xScale = fCoord->GetXScale();
313  const Double_t yScale = fCoord->GetYScale();
314  const Double_t zScale = fCoord->GetZScale();
315  const TAxis *xA = fXAxis;
316  const TAxis *yA = fYAxis;
317  const TAxis *zA = fZAxis;
318 
319  Double_t maxContent = TMath::Max(TMath::Abs(fMinMaxVal.first), TMath::Abs(fMinMaxVal.second));
320  if(!maxContent)//bad, find better way to check zero.
321  maxContent = 1.;
322 
323  for (UInt_t hNum = 0; hNum < fData->fHists.size(); ++hNum) {
324  const TH3 *h = fData->fHists[hNum].first;
325  const TGLTH3Composition::ETH3BinShape shape = fData->fHists[hNum].second;
326  SetColor(h->GetFillColor());
327 
328  for(Int_t ir = irInit, i = iInit; addI > 0 ? i < nX : i >= 0; ir += addI, i += addI) {
329  for(Int_t jr = jrInit, j = jInit; addJ > 0 ? j < nY : j >= 0; jr += addJ, j += addJ) {
330  for(Int_t kr = krInit, k = kInit; addK > 0 ? k < nZ : k >= 0; kr += addK, k += addK) {
331  const Double_t binContent = h->GetBinContent(ir, jr, kr);
332  const Double_t w = TMath::Abs(binContent) / maxContent;
333  if (!w)
334  continue;
335 
336  const Double_t xMin = xScale * (xA->GetBinLowEdge(ir) / 2 + xA->GetBinUpEdge(ir) / 2 - w * xA->GetBinWidth(ir) / 2);
337  const Double_t xMax = xScale * (xA->GetBinLowEdge(ir) / 2 + xA->GetBinUpEdge(ir) / 2 + w * xA->GetBinWidth(ir) / 2);
338  const Double_t yMin = yScale * (yA->GetBinLowEdge(jr) / 2 + yA->GetBinUpEdge(jr) / 2 - w * yA->GetBinWidth(jr) / 2);
339  const Double_t yMax = yScale * (yA->GetBinLowEdge(jr) / 2 + yA->GetBinUpEdge(jr) / 2 + w * yA->GetBinWidth(jr) / 2);
340  const Double_t zMin = zScale * (zA->GetBinLowEdge(kr) / 2 + zA->GetBinUpEdge(kr) / 2 - w * zA->GetBinWidth(kr) / 2);
341  const Double_t zMax = zScale * (zA->GetBinLowEdge(kr) / 2 + zA->GetBinUpEdge(kr) / 2 + w * zA->GetBinWidth(kr) / 2);
342 
343  if (fBoxCut.IsActive() && fBoxCut.IsInCut(xMin, xMax, yMin, yMax, zMin, zMax))
344  continue;
345 
346  if (shape == TGLTH3Composition::kSphere)
347  Rgl::DrawSphere(&fQuadric, xMin, xMax, yMin, yMax, zMin, zMax);
348  else
349  Rgl::DrawBoxFront(xMin, xMax, yMin, yMax, zMin, zMax, frontPoint);
350  }
351  }
352  }
353  }
354 
355  if (fBoxCut.IsActive())
357 
358  glDisable(GL_POLYGON_OFFSET_FILL);//0]
359  const TGLDisableGuard lightGuard(GL_LIGHTING);//[2 - 2]
360  glColor4d(0., 0., 0., 0.25);
361  glPolygonMode(GL_FRONT, GL_LINE);//[3
362 
363  const TGLEnableGuard blendGuard(GL_BLEND);//[4-4] + 1]
364  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
365  const TGLEnableGuard smoothGuard(GL_LINE_SMOOTH);//[5-5]
366  glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
367 
368  for (UInt_t hNum = 0; hNum < fData->fHists.size(); ++hNum) {
369  if (fData->fHists[hNum].second == TGLTH3Composition::kSphere)
370  continue;//No outlines for spherical bins.
371 
372  const TH3 *h = fData->fHists[hNum].first;
373 
374  for(Int_t ir = irInit, i = iInit; addI > 0 ? i < nX : i >= 0; ir += addI, i += addI) {
375  for(Int_t jr = jrInit, j = jInit; addJ > 0 ? j < nY : j >= 0; jr += addJ, j += addJ) {
376  for(Int_t kr = krInit, k = kInit; addK > 0 ? k < nZ : k >= 0; kr += addK, k += addK) {
377  const Double_t w = TMath::Abs(h->GetBinContent(ir, jr, kr)) / maxContent;
378  if (!w)
379  continue;
380 
381  const Double_t xMin = xScale * (xA->GetBinLowEdge(ir) / 2 + xA->GetBinUpEdge(ir) / 2 - w * xA->GetBinWidth(ir) / 2);
382  const Double_t xMax = xScale * (xA->GetBinLowEdge(ir) / 2 + xA->GetBinUpEdge(ir) / 2 + w * xA->GetBinWidth(ir) / 2);
383  const Double_t yMin = yScale * (yA->GetBinLowEdge(jr) / 2 + yA->GetBinUpEdge(jr) / 2 - w * yA->GetBinWidth(jr) / 2);
384  const Double_t yMax = yScale * (yA->GetBinLowEdge(jr) / 2 + yA->GetBinUpEdge(jr) / 2 + w * yA->GetBinWidth(jr) / 2);
385  const Double_t zMin = zScale * (zA->GetBinLowEdge(kr) / 2 + zA->GetBinUpEdge(kr) / 2 - w * zA->GetBinWidth(kr) / 2);
386  const Double_t zMax = zScale * (zA->GetBinLowEdge(kr) / 2 + zA->GetBinUpEdge(kr) / 2 + w * zA->GetBinWidth(kr) / 2);
387 
388  if (fBoxCut.IsActive() && fBoxCut.IsInCut(xMin, xMax, yMin, yMax, zMin, zMax))
389  continue;
390 
391  Rgl::DrawBoxFront(xMin, xMax, yMin, yMax, zMin, zMax, frontPoint);
392  }
393  }
394  }
395  }
396 
397  glPolygonMode(GL_FRONT, GL_FILL);//3]
398 }
399 
400 ////////////////////////////////////////////////////////////////////////////////
401 ///Set material.
402 
404 {
405  Float_t diffColor[] = {0.8f, 0.8f, 0.8f, 0.05f};
406 
407  if (color != kWhite)
408  if (const TColor *c = gROOT->GetColor(color))
409  c->GetRGB(diffColor[0], diffColor[1], diffColor[2]);
410 
411  glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffColor);
412  const Float_t specColor[] = {1.f, 1.f, 1.f, 1.f};
413  glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specColor);
414  glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 70.f);
415 }
416 
417 namespace {
418 
419 ////////////////////////////////////////////////////////////////////////////////
420 
421 void AxisError(const TString & errorMsg)
422 {
423  Error("TGLTH3Composition::AddTH3", "%s", errorMsg.Data());
424  throw std::runtime_error(errorMsg.Data());
425 }
426 
427 ////////////////////////////////////////////////////////////////////////////////
428 ///Check number of bins.
429 
430 void CompareAxes(const TAxis *a1, const TAxis *a2, const TString &axisName)
431 {
432  if (a1->GetNbins() != a2->GetNbins())
433  AxisError("New hist has different number of bins along " + axisName);
434 
435  //Check bin ranges.
436  const Int_t firstBin1 = a1->GetFirst(), lastBin1 = a1->GetLast();
437  const Int_t firstBin2 = a2->GetFirst(), lastBin2 = a2->GetLast();
438 
439  if (firstBin1 != firstBin2)
440  AxisError("New hist has different first bin along " + axisName);
441 
442  if (lastBin1 != lastBin2)
443  AxisError("New hist has different last bin along " + axisName);
444 
445  const Double_t eps = 1e-7;//?????:((((
446  //Check axes ranges.
447  if (TMath::Abs(a1->GetBinLowEdge(firstBin1) - a2->GetBinLowEdge(firstBin2)) > eps)
448  AxisError("New hist has different low edge along " + axisName);
449  if (TMath::Abs(a1->GetBinUpEdge(lastBin1) - a2->GetBinUpEdge(lastBin2)) > eps)
450  AxisError("New hist has different low edge along " + axisName);
451 }
452 
453 }
void DrawBox(Bool_t selectionPass, Int_t selected) const
Draw cut as a semi-transparent box.
Int_t GetFrontPoint() const
The nearest point.
Definition: TGLPlotBox.cxx:294
void RestoreModelviewMatrix() const
Camera for TGLPlotPainter and sub-classes.
Definition: TGLPlotCamera.h:21
TGLTH3Composition * fData
Int_t GetFirstXBin() const
void Pan(Int_t px, Int_t py)
User&#39;s moving mouse cursor, with middle mouse button pressed (for pad).
Int_t GetFirst() const
Return first bin on the axis i.e.
Definition: TAxis.cxx:444
Int_t GetNYBins() const
Number of Y bins.
void MoveBox(Int_t px, Int_t py, Int_t axisID)
Move box cut along selected direction.
float Float_t
Definition: RtypesCore.h:53
const char Option_t
Definition: RtypesCore.h:62
virtual Double_t GetBinLowEdge(Int_t bin) const
Return low edge of bin.
Definition: TAxis.cxx:504
TAxis fYaxis
Y axis descriptor.
Definition: TH1.h:88
std::unique_ptr< TGLHistPainter > fPainter
void StartPan(Int_t px, Int_t py)
User clicks somewhere (px, py).
const TGLVertex3 * Get3DBox() const
Get 3D box.
Definition: TGLPlotBox.cxx:303
SCoord_t fX
Definition: TPoint.h:35
virtual Int_t GetNbinsZ() const
Definition: TH1.h:293
#define gROOT
Definition: TROOT.h:410
SCoord_t fY
Definition: TPoint.h:36
Basic string class.
Definition: TString.h:131
Int_t GetNXBins() const
Number of X bins.
#define f(i)
Definition: RSha256.hxx:104
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:168
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
void TurnOnOff()
Turn the box cut on/off.
virtual Double_t GetBinContent(Int_t bin) const
Return content of bin number bin.
Definition: TH3.h:91
void DeInitGL() const
Return back some gl state variables.
TAxis fZaxis
Z axis descriptor.
Definition: TH1.h:89
Short_t Abs(Short_t d)
Definition: TMathBase.h:108
void ProcessEvent(Int_t event, Int_t px, Int_t py)
Switch on/off box cut.
virtual Double_t GetBinUpEdge(Int_t bin) const
Return up edge of bin.
Definition: TAxis.cxx:514
Int_t DistancetoPrimitive(Int_t px, Int_t py)
Check if "this" is under cursor.
Int_t GetNZBins() const
Number of Z bins.
void StartPan(Int_t px, Int_t py)
Move plot or box cut.
void DrawPlot() const
Draw composition of TH3s.
void Apply(Double_t phi, Double_t theta) const
Applies rotations and translations before drawing.
Bool_t IsActive() const
void Info(const char *location, const char *msgfmt,...)
void SetCamera() const
Viewport and projection.
char * GetObjectInfo(Int_t px, Int_t py) const
I cannot show bin content in a status bar - since there can be several bins in one.
Int_t GetFirstYBin() const
void SetYLog(Bool_t yLog)
If log changed, sections must be reset, set fModified.
TGLPlotBox fBackBox
void Error(const char *location, const char *msgfmt,...)
void SetViewVolume(const TGLVertex3 *box)
&#39;box&#39; is the TGLPlotPainter&#39;s back box&#39;s coordinates.
The 3-D histogram classes derived from the 1-D histogram classes.
Definition: TH3.h:31
void Paint(Option_t *option)
Paint a composition of 3d hists.
Definition: Rtypes.h:58
Double_t fPadTheta
const Rgl::Range_t & GetZRangeScaled() const
Scaled range.
TGLPlotCamera * fCamera
void RestoreProjectionMatrix() const
void DrawBoxFront(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax, Double_t zMin, Double_t zMax, Int_t fp)
Draws lego&#39;s bar as a 3d box.
Definition: TGLUtil.cxx:2974
Int_t GetLastYBin() const
Int_t GetLast() const
Return last bin on the axis i.e.
Definition: TAxis.cxx:455
Class to manage histogram axis.
Definition: TAxis.h:30
TGLTH3Composition()
I have to define it, since explicit copy ctor was declared.
std::pair< Double_t, Double_t > fMinMaxVal
Helper class for plot-painters holding information about axis ranges, numbers of bins and flags if ce...
void ResetModified()
Reset modified.
void Pan(Int_t px, Int_t py)
Pan camera.
unsigned int UInt_t
Definition: RtypesCore.h:42
char * Form(const char *fmt,...)
void SetXLog(Bool_t xLog)
If log changed, sections must be reset, set fModified.
TAxis * GetYaxis()
Definition: TH1.h:316
std::vector< TH3Pair_t > fHists
Base class for plot-painters that provide GL rendering of various 2D and 3D histograms, functions and parametric surfaces.
std::vector< Double_t > fZLevels
#define gVirtualX
Definition: TVirtualX.h:350
#define h(i)
Definition: RSha256.hxx:106
const Bool_t kFALSE
Definition: RtypesCore.h:88
void DrawBox(Int_t selectedPart, Bool_t selectionPass, const std::vector< Double_t > &zLevels, Bool_t highColor) const
Draw back box for a plot.
Definition: TGLPlotBox.cxx:184
Double_t GetYScale() const
std::pair< const TH3 *, ETH3BinShape > TH3Pair_t
#define ClassImp(name)
Definition: Rtypes.h:359
double Double_t
Definition: RtypesCore.h:55
void SetColor(Int_t color) const
Set material.
Bool_t Modified() const
Modified.
unsigned long ULong_t
Definition: RtypesCore.h:51
virtual Color_t GetFillColor() const
Return the fill area color.
Definition: TAttFill.h:30
void SaveProjectionMatrix() const
you should not use this method at all Int_t Int_t Double_t Double_t Double_t e
Definition: TRolke.cxx:630
The color creation and management class.
Definition: TColor.h:19
Int_t GetFirstZBin() const
Bool_t SetRanges(const TH1 *hist, Bool_t errors=kFALSE, Bool_t zBins=kFALSE)
Set bin ranges, ranges.
const Rgl::Range_t & GetYRangeScaled() const
Scaled range.
Int_t GetLastXBin() const
TAxis * GetZaxis()
Definition: TH1.h:317
void DrawSphere(TGLQuadric *quadric, Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax, Double_t zMin, Double_t zMax)
Cylinder for lego3.
Definition: TGLUtil.cxx:3242
The histogram painter class using OpenGL.
void ExecuteEvent(Int_t event, Int_t px, Int_t py)
Mouse and keyboard events.
void InitGL() const
Initialize some gl state variables.
void AddOption(const TString &option)
No options for composition.
virtual Double_t GetBinWidth(Int_t bin) const
Return bin width.
Definition: TAxis.cxx:526
char * GetPlotInfo(Int_t px, Int_t py)
Will be never called from TPad.
void SetZLog(Bool_t zLog)
If log changed, sections must be reset, set fModified.
void StartMovement(Int_t px, Int_t py)
Start cut&#39;s movement.
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:200
void SetPlotBox(const Rgl::Range_t &xRange, const Rgl::Range_t &yRange, const Rgl::Range_t &zRange)
Set up a frame box.
Definition: TGLPlotBox.cxx:198
void AddTH3(const TH3 *hist, ETH3BinShape shape=kBox)
Add TH3 into collection.
const Rgl::Range_t & GetXRangeScaled() const
Scaled range.
#define c(i)
Definition: RSha256.hxx:101
TAxis fXaxis
X axis descriptor.
Definition: TH1.h:87
virtual Int_t GetNbinsX() const
Definition: TH1.h:291
Int_t GetNbins() const
Definition: TAxis.h:121
Bool_t fUpdateSelection
virtual void Set(Int_t nbins, Double_t xmin, Double_t xmax)
Initialize axis with fix bins.
Definition: TAxis.cxx:717
Int_t GetLastZBin() const
Int_t GetHeight() const
viewport[3]
void SaveModelviewMatrix() const
TGLPlotCoordinates * fCoord
Double_t Y() const
Definition: TGLUtil.h:120
virtual void Paint()
Draw lego/surf/whatever you can.
const Bool_t kTRUE
Definition: RtypesCore.h:87
TGLBoxCut fBoxCut
Double_t GetZScale() const
TAxis * GetXaxis()
Get the behaviour adopted by the object about the statoverflows. See EStatOverflows for more informat...
Definition: TH1.h:315
TGLTH3CompositionPainter(TGLTH3Composition *data, TGLPlotCamera *camera, TGLPlotCoordinates *coord)
Ctor.
Double_t GetXScale() const
virtual Int_t GetNbinsY() const
Definition: TH1.h:292
const char * Data() const
Definition: TString.h:364
const TGLVertex3 * Get2DBox() const
Get 2D box.
Definition: TGLPlotBox.cxx:312
Bool_t IsInCut(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax, Double_t zMin, Double_t zMax) const
Check, if box defined by xmin/xmax etc. is in cut.