Logo ROOT  

Reference Guide
 
Loading...
Searching...
No Matches
TGLLegoPainter.cxx
Go to the documentation of this file.
1// @(#)root/gl:$Id$
2// Author: Timur Pocheptsov 14/06/2006
3
4/*************************************************************************
5 * Copyright (C) 1995-2004, 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#include <algorithm>
12#include <cctype>
13
14#include "KeySymbols.h"
15#include "TVirtualX.h"
16#include "Buttons.h"
17#include "TString.h"
18#include "TColor.h"
19#include "TROOT.h"
20#include "TStyle.h"
21#include "TAxis.h"
22#include "TMath.h"
23#include "TH1.h"
24
25#include "TGLLegoPainter.h"
26#include "TGLPlotCamera.h"
27#include "TGLIncludes.h"
28
29/** \class TGLLegoPainter
30\ingroup opengl
31Plot-painter implementing LEGO rendering of TH2 histograms in
32cartesian, polar, cylindrical and spherical coordinates.
33*/
34
35ClassImp(TGLLegoPainter);
36
37////////////////////////////////////////////////////////////////////////////////
38///Ctor.
39
47
48////////////////////////////////////////////////////////////////////////////////
49///Obtain bin's info (i, j, value).
50
51char *TGLLegoPainter::GetPlotInfo(Int_t /*px*/, Int_t /*py*/)
52{
53 fBinInfo = "";
54
55 if (fSelectedPart) {
56 if (fSelectedPart < fSelectionBase) {
57 if (fHist->Class())
58 fBinInfo += fHist->Class()->GetName();
59 fBinInfo += "::";
60 fBinInfo += fHist->GetName();
61 } else if (!fHighColor) {
62 const Int_t binI = (fSelectedPart - fSelectionBase) / fCoord->GetNYBins() + fCoord->GetFirstXBin();
63 const Int_t binJ = (fSelectedPart - fSelectionBase) % fCoord->GetNYBins() + fCoord->GetFirstYBin();
64 fBinInfo.Form("(binx = %d; biny = %d; binc = %f)", binI, binJ,
65 fHist->GetBinContent(binI, binJ));
66 } else
67 fBinInfo = "Switch to true-color mode to obtain correct info";
68 }
69
70 return (Char_t *)fBinInfo.Data();
71}
72
73////////////////////////////////////////////////////////////////////////////////
74///Select method.
75
76Bool_t TGLLegoPainter::InitGeometry()
77{
78 Bool_t ret = kFALSE;
79 switch (fCoord->GetCoordType()) {
80 case kGLCartesian:
81 ret = InitGeometryCartesian(); break;
82 case kGLPolar:
83 ret = InitGeometryPolar(); break;
84 case kGLCylindrical:
85 ret = InitGeometryCylindrical(); break;
86 case kGLSpherical:
87 ret = InitGeometrySpherical(); break;
88 default:
89 return kFALSE;
90 }
91 if (ret && fCamera) fCamera->SetViewVolume(fBackBox.Get3DBox());
92 return ret;
93}
94
95////////////////////////////////////////////////////////////////////////////////
96///Geometry for lego in cartesian coords.
97
98Bool_t TGLLegoPainter::InitGeometryCartesian()
99{
100 if (!fCoord->SetRanges(fHist, fDrawErrors, kFALSE))
101 return kFALSE;
102
103 fBackBox.SetPlotBox(fCoord->GetXRangeScaled(), fCoord->GetYRangeScaled(), fCoord->GetZRangeScaled());
104
105 //Find bin edges
106 const Int_t nX = fCoord->GetNXBins();
107 const Double_t barWidth = fHist->GetBarWidth(), barOffset = fHist->GetBarOffset();
108 const TGLVertex3 *frame = fBackBox.Get3DBox();
109 fXEdges.resize(nX);
110
111 if (fCoord->GetXLog()) {
112 for (Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {
113 const Double_t xWidth = fXAxis->GetBinWidth(ir);
114 Double_t low = fXAxis->GetBinLowEdge(ir) + xWidth * barOffset;
115 fXEdges[i].first = TMath::Log10(low) * fCoord->GetXScale();
116 fXEdges[i].second = TMath::Log10(low + xWidth * barWidth) * fCoord->GetXScale();
117 if (fXEdges[i].second > frame[1].X())
118 fXEdges[i].second = frame[1].X();
119 if (fXEdges[i].first < frame[0].X())
120 fXEdges[i].first = frame[0].X();
121 if (fXEdges[i].second < frame[0].X())
122 fXEdges[i].second = frame[0].X();
123 }
124 } else {
125 for (Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {
126 const Double_t xWidth = fXAxis->GetBinWidth(ir);
127 fXEdges[i].first = (fXAxis->GetBinLowEdge(ir) + xWidth * barOffset) * fCoord->GetXScale();
128 fXEdges[i].second = fXEdges[i].first + xWidth * barWidth * fCoord->GetXScale();
129 if (fXEdges[i].second > frame[1].X())
130 fXEdges[i].second = frame[1].X();
131 if (fXEdges[i].first < frame[0].X())
132 fXEdges[i].first = frame[0].X();
133 if (fXEdges[i].second < frame[0].X())
134 fXEdges[i].second = frame[0].X();
135 }
136 }
137
138 const Int_t nY = fCoord->GetNYBins();
139 fYEdges.resize(nY);
140
141 if (fCoord->GetYLog()) {
142 for (Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {
143 const Double_t yWidth = fYAxis->GetBinWidth(jr);
144 Double_t low = fYAxis->GetBinLowEdge(jr) + yWidth * barOffset;
145 fYEdges[j].first = TMath::Log10(low) * fCoord->GetYScale();
146 fYEdges[j].second = TMath::Log10(low + yWidth * barWidth) * fCoord->GetYScale();
147 if (fYEdges[j].second > frame[2].Y())
148 fYEdges[j].second = frame[2].Y();
149 if (fYEdges[j].first < frame[0].Y())
150 fYEdges[j].first = frame[0].Y();
151 if (fYEdges[j].second < frame[0].Y())
152 fYEdges[j].second = frame[0].Y();
153 }
154 } else {
155 for (Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {
156 const Double_t yWidth = fYAxis->GetBinWidth(jr);
157 fYEdges[j].first = (fYAxis->GetBinLowEdge(jr) + yWidth * barOffset) * fCoord->GetYScale();
158 fYEdges[j].second = fYEdges[j].first + yWidth * barWidth * fCoord->GetYScale();
159 if (fYEdges[j].second > frame[2].Y())
160 fYEdges[j].second = frame[2].Y();
161 if (fYEdges[j].first < frame[0].Y())
162 fYEdges[j].first = frame[0].Y();
163 if (fYEdges[j].second < frame[0].Y())
164 fYEdges[j].second = frame[0].Y();
165 }
166 }
167
168 fMinZ = frame[0].Z();
169 if (fMinZ < 0.)
170 frame[4].Z() > 0. ? fMinZ = 0. : fMinZ = frame[4].Z();
171
172 if (fCoord->Modified()) {
173 fUpdateSelection = kTRUE;
174 fXOZSectionPos = frame[0].Y();
175 fYOZSectionPos = frame[0].X();
176 fXOYSectionPos = frame[0].Z();
177 fCoord->ResetModified();
178 Rgl::SetZLevels(fZAxis, fCoord->GetZRange().first, fCoord->GetZRange().second, fCoord->GetZScale(), fZLevels);
179 }
180
181 fMinMaxVal.first = fHist->GetBinContent(fCoord->GetFirstXBin(), fCoord->GetFirstYBin());
182 fMinMaxVal.second = fMinMaxVal.first;
183
184 for (Int_t i = fCoord->GetFirstXBin(), e = fCoord->GetLastXBin(); i <= e; ++i) {
185 for (Int_t j = fCoord->GetFirstYBin(), e1 = fCoord->GetLastYBin(); j <= e1; ++j) {
186 Double_t val = fHist->GetBinContent(i, j);
187 fMinMaxVal.first = TMath::Min(fMinMaxVal.first, val);
188 fMinMaxVal.second = TMath::Max(fMinMaxVal.second, val);
189 }
190 }
191
192 ClampZ(fMinMaxVal.first);
193 ClampZ(fMinMaxVal.second);
194
195 return kTRUE;
196}
197
198////////////////////////////////////////////////////////////////////////////////
199///Geometry for lego in polar coords.
200
201Bool_t TGLLegoPainter::InitGeometryPolar()
202{
203 if (!fCoord->SetRanges(fHist, kFALSE, kFALSE))
204 return kFALSE;
205
206 fBackBox.SetPlotBox(fCoord->GetXRangeScaled(), fCoord->GetYRangeScaled(), fCoord->GetZRangeScaled());
207
208 if (fCoord->Modified()) {
209 fUpdateSelection = kTRUE;
210 fCoord->ResetModified();
211 }
212
213 const Int_t nY = fCoord->GetNYBins();//yBins.second - yBins.first + 1;
214 fYEdges.resize(nY);
215
216 for (Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {
217 fYEdges[j].first = ((fYAxis->GetBinLowEdge(jr)) - fCoord->GetYRange().first) /
218 fCoord->GetYLength() * fCoord->GetYScale();
219 fYEdges[j].second = ((fYAxis->GetBinUpEdge(jr)) - fCoord->GetYRange().first) /
220 fCoord->GetYLength() * fCoord->GetYScale();
221 }
222
223 const Int_t nX = fCoord->GetNXBins();
224 fCosSinTableX.resize(nX + 1);
225 const Double_t fullAngle = fXAxis->GetXmax() - fXAxis->GetXmin();
226 const Double_t phiLow = fXAxis->GetXmin();
227 Double_t angle = 0;
228 for (Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {
229 angle = (fXAxis->GetBinLowEdge(ir) - phiLow) / fullAngle * TMath::TwoPi();
230 fCosSinTableX[i].first = TMath::Cos(angle);
231 fCosSinTableX[i].second = TMath::Sin(angle);
232 }
233 angle = (fXAxis->GetBinUpEdge(fCoord->GetLastXBin()) - phiLow) / fullAngle * TMath::TwoPi();
234 fCosSinTableX[nX].first = TMath::Cos(angle);
235 fCosSinTableX[nX].second = TMath::Sin(angle);
236
237 fMinZ = fBackBox.Get3DBox()[0].Z();
238 if (fMinZ < 0.)
239 fBackBox.Get3DBox()[4].Z() > 0. ? fMinZ = 0. : fMinZ = fBackBox.Get3DBox()[4].Z();
240
241 fMinMaxVal.first = fHist->GetBinContent(fCoord->GetFirstXBin(), fCoord->GetFirstYBin());
242 fMinMaxVal.second = fMinMaxVal.first;
243
244 for (Int_t i = fCoord->GetFirstXBin(), e = fCoord->GetLastXBin(); i <= e; ++i) {
245 for (Int_t j = fCoord->GetFirstYBin(), e1 = fCoord->GetLastYBin(); j <= e1; ++j) {
246 Double_t val = fHist->GetBinContent(i, j);
247 fMinMaxVal.first = TMath::Min(fMinMaxVal.first, val);
248 fMinMaxVal.second = TMath::Max(fMinMaxVal.second, val);
249 }
250 }
251
252 ClampZ(fMinMaxVal.first);
253 ClampZ(fMinMaxVal.second);
254
255 return kTRUE;
256}
257
258////////////////////////////////////////////////////////////////////////////////
259///Geometry for lego in cylindrical coords.
260
261Bool_t TGLLegoPainter::InitGeometryCylindrical()
262{
263 if (!fCoord->SetRanges(fHist, kFALSE, kFALSE))
264 return kFALSE;
265
266 fBackBox.SetPlotBox(fCoord->GetXRangeScaled(), fCoord->GetYRangeScaled(), fCoord->GetZRangeScaled());
267
268 const Int_t nY = fCoord->GetNYBins();
269 fYEdges.resize(nY);
270
271 if (fCoord->GetYLog()) {
272 for (Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {
273 fYEdges[j].first = TMath::Log10(fYAxis->GetBinLowEdge(jr)) * fCoord->GetYScale();
274 fYEdges[j].second = TMath::Log10(fYAxis->GetBinUpEdge(jr)) * fCoord->GetYScale();
275 }
276 } else {
277 for (Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {
278 fYEdges[j].first = fYAxis->GetBinLowEdge(jr) * fCoord->GetYScale();
279 fYEdges[j].second = fYAxis->GetBinUpEdge(jr) * fCoord->GetYScale();
280 }
281 }
282
283 const Int_t nX = fCoord->GetNXBins();
284 fCosSinTableX.resize(nX + 1);
285 const Double_t fullAngle = fXAxis->GetXmax() - fXAxis->GetXmin();
286 const Double_t phiLow = fXAxis->GetXmin();
287 Double_t angle = 0.;
288 for (Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {
289 angle = (fXAxis->GetBinLowEdge(ir) - phiLow) / fullAngle * TMath::TwoPi();
290 fCosSinTableX[i].first = TMath::Cos(angle);
291 fCosSinTableX[i].second = TMath::Sin(angle);
292 }
293 angle = (fXAxis->GetBinUpEdge(fCoord->GetLastXBin()) - phiLow) / fullAngle * TMath::TwoPi();
294 fCosSinTableX[nX].first = TMath::Cos(angle);
295 fCosSinTableX[nX].second = TMath::Sin(angle);
296
297 if (fCoord->Modified()) {
298 fUpdateSelection = kTRUE;
299 fCoord->ResetModified();
300 }
301
302 fMinZ = fCoord->GetZRange().first;
303 if (fMinZ < 0.)
304 fCoord->GetZRange().second > 0. ? fMinZ = 0. : fMinZ = fCoord->GetZRange().second;
305
306
307 fMinMaxVal.first = fHist->GetBinContent(fCoord->GetFirstXBin(), fCoord->GetFirstYBin());
308 fMinMaxVal.second = fMinMaxVal.first;
309
310 for (Int_t i = fCoord->GetFirstXBin(), e = fCoord->GetLastXBin(); i <= e; ++i) {
311 for (Int_t j = fCoord->GetFirstYBin(), e1 = fCoord->GetLastYBin(); j <= e1; ++j) {
312 Double_t val = fHist->GetBinContent(i, j);
313 fMinMaxVal.first = TMath::Min(fMinMaxVal.first, val);
314 fMinMaxVal.second = TMath::Max(fMinMaxVal.second, val);
315 }
316 }
317
318 return kTRUE;
319}
320
321////////////////////////////////////////////////////////////////////////////////
322///Geometry for lego in spherical coords.
323
324Bool_t TGLLegoPainter::InitGeometrySpherical()
325{
326 if (!fCoord->SetRanges(fHist, kFALSE, kFALSE))
327 return kFALSE;
328
329 fBackBox.SetPlotBox(fCoord->GetXRangeScaled(), fCoord->GetYRangeScaled(), fCoord->GetZRangeScaled());
330
331 const Int_t nY = fCoord->GetNYBins();
332 fCosSinTableY.resize(nY + 1);
333 const Double_t fullTheta = fYAxis->GetXmax() - fYAxis->GetXmin();
334 const Double_t thetaLow = fYAxis->GetXmin();
335 Double_t angle = 0.;
336 for (Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {
337 angle = (fYAxis->GetBinLowEdge(jr) - thetaLow) / fullTheta * TMath::Pi();
338 fCosSinTableY[j].first = TMath::Cos(angle);
339 fCosSinTableY[j].second = TMath::Sin(angle);
340 }
341 angle = (fYAxis->GetBinUpEdge(fCoord->GetLastYBin()) - thetaLow) / fullTheta * TMath::Pi();
342 fCosSinTableY[nY].first = TMath::Cos(angle);
343 fCosSinTableY[nY].second = TMath::Sin(angle);
344
345 const Int_t nX = fCoord->GetNXBins();
346 fCosSinTableX.resize(nX + 1);
347 const Double_t fullPhi = fXAxis->GetXmax() - fXAxis->GetXmin();
348 const Double_t phiLow = fXAxis->GetXmin();
349
350 for (Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {
351 angle = (fXAxis->GetBinLowEdge(ir) - phiLow) / fullPhi * TMath::TwoPi();
352 fCosSinTableX[i].first = TMath::Cos(angle);
353 fCosSinTableX[i].second = TMath::Sin(angle);
354 }
355
356 angle = (fXAxis->GetBinUpEdge(fCoord->GetLastXBin()) - phiLow) / fullPhi * TMath::TwoPi();
357 fCosSinTableX[nX].first = TMath::Cos(angle);
358 fCosSinTableX[nX].second = TMath::Sin(angle);
359
360 fMinZ = fCoord->GetZRange().first;
361 if (fMinZ < 0.)
362 fCoord->GetZRange().second > 0. ? fMinZ = 0. : fMinZ = fCoord->GetZRange().second;
363
364 fMinMaxVal.first = fHist->GetBinContent(fCoord->GetFirstXBin(), fCoord->GetFirstYBin());
365 fMinMaxVal.second = fMinMaxVal.first;
366
367 for (Int_t i = fCoord->GetFirstXBin(), e = fCoord->GetLastXBin(); i <= e; ++i) {
368 for (Int_t j = fCoord->GetFirstYBin(), e1 = fCoord->GetLastYBin(); j <= e1; ++j) {
369 Double_t val = fHist->GetBinContent(i, j);
370 fMinMaxVal.first = TMath::Min(fMinMaxVal.first, val);
371 fMinMaxVal.second = TMath::Max(fMinMaxVal.second, val);
372 }
373 }
374
375
376 return kTRUE;
377}
378
379////////////////////////////////////////////////////////////////////////////////
380///User clicks on a lego with middle mouse button (middle for pad).
381
382void TGLLegoPainter::StartPan(Int_t px, Int_t py)
383{
384 fMousePosition.fX = px;
385 fMousePosition.fY = fCamera->GetHeight() - py;
386 fCamera->StartPan(px, py);
387 fBoxCut.StartMovement(px, py);
388}
389
390////////////////////////////////////////////////////////////////////////////////
391///Move lego or section.
392
393void TGLLegoPainter::Pan(Int_t px, Int_t py)
394{
395 if (fSelectedPart >= fSelectionBase || fSelectedPart == 1) {
396 SaveModelviewMatrix();
397 SaveProjectionMatrix();
398
399 fCamera->SetCamera();
400 fCamera->Apply(fPadPhi, fPadTheta);
401 fCamera->Pan(px, py);
402
403 RestoreProjectionMatrix();
404 RestoreModelviewMatrix();
405 } else if (fSelectedPart > 0) {
406 //Convert py into bottom-top orientation.
407 py = fCamera->GetHeight() - py;
408
409 SaveModelviewMatrix();
410 SaveProjectionMatrix();
411
412 fCamera->SetCamera();
413 fCamera->Apply(fPadPhi, fPadTheta);
414
415 if (!fHighColor) {
416 if (fBoxCut.IsActive() && (fSelectedPart >= kXAxis && fSelectedPart <= kZAxis))
417 fBoxCut.MoveBox(px, py, fSelectedPart);
418 else
419 MoveSection(px, py);
420 } else
421 MoveSection(px, py);
422
423 RestoreProjectionMatrix();
424 RestoreModelviewMatrix();
425 }
426
427 fMousePosition.fX = px, fMousePosition.fY = py;
428 fUpdateSelection = kTRUE;
429}
430
431////////////////////////////////////////////////////////////////////////////////
432///Parse additional options.
433
434void TGLLegoPainter::AddOption(const TString &option)
435{
436 const Ssiz_t legoPos = option.Index("lego");//"lego" _already_ _exists_ in a string.
437 if (legoPos + 4 < option.Length() && isdigit(option[legoPos + 4])) {
438 switch (option[legoPos + 4] - '0') {
439 case 1:
440 fLegoType = kColorSimple;
441 break;
442 case 2:
443 fLegoType = kColorLevel;
444 break;
445 case 3:
446 fLegoType = kCylindricBars;
447 break;
448 default:
449 fLegoType = kColorSimple;
450 break;
451 }
452 } else
453 fLegoType = kColorSimple;
454 //check 'e' option
455 Ssiz_t ePos = option.Index("e");
456 if (ePos == legoPos + 1)
457 ePos = option.Index("e", legoPos + 4);
458 fDrawErrors = ePos != kNPOS ? kTRUE : kFALSE;
459
460 option.Index("z") == kNPOS ? fDrawPalette = kFALSE : fDrawPalette = kTRUE;
461}
462
463////////////////////////////////////////////////////////////////////////////////
464///Initialize some gl state variables.
465
466void TGLLegoPainter::InitGL()const
467{
468 glEnable(GL_DEPTH_TEST);
469 glEnable(GL_LIGHTING);
470 glEnable(GL_LIGHT0);
471 //For lego, back polygons are culled (but not for sections).
472 glEnable(GL_CULL_FACE);
473 glCullFace(GL_BACK);
474
475 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
476}
477
478////////////////////////////////////////////////////////////////////////////////
479///Return some gl states to original values.
480
481void TGLLegoPainter::DeInitGL()const
482{
483 glDisable(GL_DEPTH_TEST);
484 glDisable(GL_LIGHTING);
485 glDisable(GL_LIGHT0);
486 glDisable(GL_CULL_FACE);
487 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
488}
489
490////////////////////////////////////////////////////////////////////////////////
491///Select method corresponding to coordinate system.
492
493void TGLLegoPainter::DrawPlot()const
494{
495 //Shift plot to point of origin.
496 const Rgl::PlotTranslation trGuard(this);
497
498 switch (fCoord->GetCoordType()) {
499 case kGLCartesian:
500 return DrawLegoCartesian();
501 case kGLPolar:
502 return DrawLegoPolar();
503 case kGLCylindrical:
504 return DrawLegoCylindrical();
505 case kGLSpherical:
506 return DrawLegoSpherical();
507 default:;
508 }
509}
510
511////////////////////////////////////////////////////////////////////////////////
512///Lego in cartesian system.
513
514void TGLLegoPainter::DrawLegoCartesian()const
515{
516 if (fCoord->GetCoordType() == kGLCartesian) {
517 fBackBox.DrawBox(fSelectedPart, fSelectionPass, fZLevels, fHighColor);
518 const TGLDisableGuard cullGuard(GL_CULL_FACE);
519 DrawSections();
520 }
521
522 //const TGLDisableGuard depthTest(GL_DEPTH_TEST); //[0-0]
523
524 if (!fSelectionPass) {
525 glEnable(GL_POLYGON_OFFSET_FILL);//[0
526 glPolygonOffset(1.f, 1.f);
527 SetLegoColor();
528 if (fXOZSectionPos > fBackBox.Get3DBox()[0].Y() || fYOZSectionPos> fBackBox.Get3DBox()[0].X()) {
529 //Lego is semi-transparent if we have any sections.
530 glEnable(GL_BLEND);//[1
531 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
532 }
533 }
534
535 //Using front point, find the correct order to draw bars from
536 //back to front (it's important only for semi-transparent lego).
537 //Only in cartesian.
538 const Int_t nX = fXEdges.size();
539 const Int_t nY = fYEdges.size();
540 const Int_t frontPoint = fBackBox.GetFrontPoint();
541 Int_t iInit = 0, jInit = 0, irInit = fCoord->GetFirstXBin(), jrInit = fCoord->GetFirstYBin();
542 const Int_t addI = frontPoint == 2 || frontPoint == 1 ? 1 : (iInit = nX - 1, irInit = fCoord->GetLastXBin(), -1);
543 const Int_t addJ = frontPoint == 2 || frontPoint == 3 ? 1 : (jInit = nY - 1, jrInit = fCoord->GetLastYBin(), -1);
544
545 if (fLegoType == kColorLevel && !fSelectionPass) {
546 if (!PreparePalette()) {
547 fLegoType = kColorSimple;
548 fDrawPalette = kFALSE;
549 } else
550 fPalette.EnableTexture(GL_MODULATE);
551 }
552
553 if (fSelectionPass && fHighColor)
554 Rgl::ObjectIDToColor(fSelectionBase, kTRUE);
555
556 for(Int_t i = iInit, ir = irInit; addI > 0 ? i < nX : i >= 0; i += addI, ir += addI) {
557 for(Int_t j = jInit, jr = jrInit; addJ > 0 ? j < nY : j >= 0; j += addJ, jr += addJ) {
558 Double_t zMax = fHist->GetBinContent(ir, jr) * fCoord->GetFactor();
559 if (!ClampZ(zMax))
560 continue;
561
562 const Int_t binID = fSelectionBase + i * fCoord->GetNYBins() + j;
563
564 if (fSelectionPass && !fHighColor)
565 Rgl::ObjectIDToColor(binID, kFALSE);
566 else if(!fHighColor && fSelectedPart == binID)
567 glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gOrangeEmission);
568
569 if (fLegoType == kCylindricBars) {
570 Rgl::DrawCylinder(&fQuadric, fXEdges[i].first, fXEdges[i].second, fYEdges[j].first,
571 fYEdges[j].second, fMinZ, zMax);
572 } else if (fLegoType == kColorLevel && !fSelectionPass) {
573 Rgl::DrawBoxFrontTextured(fXEdges[i].first, fXEdges[i].second, fYEdges[j].first,
574 fYEdges[j].second, fMinZ, zMax, fPalette.GetTexCoord(fMinZ),
575 fPalette.GetTexCoord(zMax), frontPoint);
576 } else {
577 Rgl::DrawBoxFront(fXEdges[i].first, fXEdges[i].second, fYEdges[j].first,
578 fYEdges[j].second, fMinZ, zMax, frontPoint);
579 }
580
581 if (!fHighColor && !fSelectionPass && fSelectedPart == binID)
582 glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gNullEmission);
583 }
584 }
585
586 if (fLegoType == kColorLevel && !fSelectionPass)
587 fPalette.DisableTexture();
588
589 //Draw outlines for non-cylindrical bars.
590 if (!fSelectionPass) {
591 glDisable(GL_POLYGON_OFFSET_FILL);//0]
592 const TGLDisableGuard lightGuard(GL_LIGHTING);//[2 - 2]
593 if (fXOZSectionPos <= fBackBox.Get3DBox()[0].Y() && fYOZSectionPos <= fBackBox.Get3DBox()[0].X())
594 glColor3d(0., 0., 0.);
595 else
596 glColor4d(0., 0., 0., 0.4);
597 glPolygonMode(GL_FRONT, GL_LINE);//[3
598
599 const TGLEnableGuard blendGuard(GL_BLEND);//[4-4] + 1]
600 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
601 const TGLEnableGuard smoothGuard(GL_LINE_SMOOTH);//[5-5]
602 glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
603
604 for(Int_t i = iInit, ir = irInit; addI > 0 ? i < nX : i >= 0; i += addI, ir += addI) {
605 for(Int_t j = jInit, jr = jrInit; addJ > 0 ? j < nY : j >= 0; j += addJ, jr += addJ) {
606 Double_t zMax = fHist->GetBinContent(ir, jr) * fCoord->GetFactor();
607 if (!ClampZ(zMax))
608 continue;
609 if (fLegoType != kCylindricBars) {
610 Rgl::DrawBoxFront(fXEdges[i].first, fXEdges[i].second, fYEdges[j].first,
611 fYEdges[j].second, fMinZ, zMax, frontPoint);
612 }
613 if (fDrawErrors && zMax > 0.) {
614 Double_t errorZMax = (fHist->GetBinContent(ir, jr) + fHist->GetBinError(ir, jr)) * fCoord->GetFactor();
615 ClampZ(errorZMax);
616 Rgl::DrawError(fXEdges[i].first, fXEdges[i].second, fYEdges[j].first,
617 fYEdges[j].second, zMax, errorZMax);
618 }
619 }
620 }
621
622 glPolygonMode(GL_FRONT, GL_FILL);//3]
623 }
624
625 if(!fSelectionPass && fDrawPalette)
626 DrawPalette();
627}
628
629////////////////////////////////////////////////////////////////////////////////
630///Lego in polar system.
631
632void TGLLegoPainter::DrawLegoPolar()const
633{
634 const Int_t nX = fCosSinTableX.size() - 1;
635 const Int_t nY = fYEdges.size();
636
637 if (!fSelectionPass) {
638 SetLegoColor();
639 glEnable(GL_POLYGON_OFFSET_FILL);
640 glPolygonOffset(1.f, 1.f);
641 }
642
643 Double_t points[4][2] = {};
644
645 if (fLegoType == kColorLevel && !fSelectionPass) {
646 if (!PreparePalette()) {
647 fLegoType = kColorSimple;
648 fDrawPalette = kFALSE;
649 } else
650 fPalette.EnableTexture(GL_MODULATE);
651 }
652
653 if (fHighColor && fSelectionPass)
654 Rgl::ObjectIDToColor(fSelectionBase, kTRUE);
655
656 for(Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {
657 for(Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {
658 Double_t zMax = fHist->GetBinContent(ir, jr);
659 if (!ClampZ(zMax))
660 continue;
661 points[0][0] = fYEdges[j].first * fCosSinTableX[i].first;
662 points[0][1] = fYEdges[j].first * fCosSinTableX[i].second;
663 points[1][0] = fYEdges[j].second * fCosSinTableX[i].first;
664 points[1][1] = fYEdges[j].second * fCosSinTableX[i].second;
665 points[2][0] = fYEdges[j].second * fCosSinTableX[i + 1].first;
666 points[2][1] = fYEdges[j].second * fCosSinTableX[i + 1].second;
667 points[3][0] = fYEdges[j].first * fCosSinTableX[i + 1].first;
668 points[3][1] = fYEdges[j].first * fCosSinTableX[i + 1].second;
669
670 const Int_t binID = fSelectionBase + i * fCoord->GetNYBins() + j;
671
672 if (!fHighColor && fSelectionPass)
673 Rgl::ObjectIDToColor(binID, kFALSE);
674 else if(!fHighColor && fSelectedPart == binID)
675 glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gOrangeEmission);
676
677 if (fLegoType == kColorLevel && !fSelectionPass)
678 Rgl::DrawTrapezoidTextured(points, fMinZ, zMax, fPalette.GetTexCoord(fMinZ),
679 fPalette.GetTexCoord(zMax));
680 else
681 Rgl::DrawTrapezoid(points, fMinZ, zMax);
682
683 if (!fHighColor && !fSelectionPass && fSelectedPart == binID)
684 glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gNullEmission);
685 }
686 }
687
688 if (fLegoType == kColorLevel && !fSelectionPass)
689 fPalette.DisableTexture();
690
691 //Draw outlines.
692 if (!fSelectionPass) {
693 glDisable(GL_POLYGON_OFFSET_FILL);//0]
694 const TGLDisableGuard lightGuard(GL_LIGHTING);//[2-2]
695 glColor3d(0., 0., 0.);
696 glPolygonMode(GL_FRONT, GL_LINE);//[3
697 const TGLEnableGuard blendGuard(GL_BLEND);
698 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
699 const TGLEnableGuard smoothGuard(GL_LINE_SMOOTH);
700 glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
701
702 for(Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {
703 for(Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {
704 Double_t zMax = fHist->GetBinContent(ir, jr);
705 if (!ClampZ(zMax))
706 continue;
707 points[0][0] = fYEdges[j].first * fCosSinTableX[i].first;
708 points[0][1] = fYEdges[j].first * fCosSinTableX[i].second;
709 points[1][0] = fYEdges[j].second * fCosSinTableX[i].first;
710 points[1][1] = fYEdges[j].second * fCosSinTableX[i].second;
711 points[2][0] = fYEdges[j].second * fCosSinTableX[i + 1].first;
712 points[2][1] = fYEdges[j].second * fCosSinTableX[i + 1].second;
713 points[3][0] = fYEdges[j].first * fCosSinTableX[i + 1].first;
714 points[3][1] = fYEdges[j].first * fCosSinTableX[i + 1].second;
715 Rgl::DrawTrapezoid(points, fMinZ, zMax, kFALSE);
716 }
717 }
718
719 glPolygonMode(GL_FRONT, GL_FILL);//3]
720 }
721
722 if(!fSelectionPass && fDrawPalette)
723 DrawPalette();
724}
725
726////////////////////////////////////////////////////////////////////////////////
727///Lego in cylindrical system.
728
729void TGLLegoPainter::DrawLegoCylindrical()const
730{
731 const Int_t nX = fCosSinTableX.size() - 1;
732 const Int_t nY = fYEdges.size();
733 Double_t legoR = gStyle->GetLegoInnerR();
734 if (legoR > 1. || legoR < 0.)
735 legoR = 0.5;
736 const Double_t rRange = fCoord->GetZLength();
737
738 if (!fSelectionPass) {
739 SetLegoColor();
740 glEnable(GL_POLYGON_OFFSET_FILL);
741 glPolygonOffset(1.f, 1.f);
742 }
743
744 Double_t points[4][2] = {};
745 const Double_t sc = (1 - legoR) * fCoord->GetXScale();
746 legoR *= fCoord->GetXScale();
747
748 if (fLegoType == kColorLevel && !fSelectionPass) {
749 if (!PreparePalette()) {
750 fLegoType = kColorSimple;
751 fDrawPalette = kFALSE;
752 } else
753 fPalette.EnableTexture(GL_MODULATE);
754 }
755
756 if (fHighColor && fSelectionPass)
757 Rgl::ObjectIDToColor(fSelectionBase, kTRUE);
758
759 for(Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {
760 for(Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {
761 Double_t zMin = legoR + (fMinZ - fCoord->GetZRange().first) / rRange * sc;
762 Double_t zMax = legoR + (fHist->GetBinContent(ir, jr) - fCoord->GetZRange().first) / rRange * sc;
763 if (zMin > zMax)
764 std::swap(zMin, zMax);
765
766 points[0][0] = fCosSinTableX[i].first * zMin;
767 points[0][1] = fCosSinTableX[i].second * zMin;
768 points[1][0] = fCosSinTableX[i].first * zMax;
769 points[1][1] = fCosSinTableX[i].second * zMax;
770 points[2][0] = fCosSinTableX[i + 1].first * zMax;
771 points[2][1] = fCosSinTableX[i + 1].second * zMax;
772 points[3][0] = fCosSinTableX[i + 1].first * zMin;
773 points[3][1] = fCosSinTableX[i + 1].second * zMin;
774
775 const Int_t binID = fSelectionBase + i * fCoord->GetNYBins() + j;
776
777 if (fSelectionPass && !fHighColor)
778 Rgl::ObjectIDToColor(binID, kFALSE);
779 else if(!fHighColor && fSelectedPart == binID)
780 glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gOrangeEmission);
781
782 if (fLegoType == kColorLevel && !fSelectionPass){
783 Rgl::DrawTrapezoidTextured2(points, fYEdges[j].first, fYEdges[j].second,
784 fPalette.GetTexCoord(fMinZ), fPalette.GetTexCoord(fHist->GetBinContent(ir, jr)));
785 }else
786 Rgl::DrawTrapezoid(points, fYEdges[j].first, fYEdges[j].second);
787
788 if(!fSelectionPass && !fHighColor && fSelectedPart == binID)
789 glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gNullEmission);
790 }
791 }
792
793 if (fLegoType == kColorLevel && !fSelectionPass)
794 fPalette.DisableTexture();
795
796 //Draw outlines.
797 if (!fSelectionPass) {
798 glDisable(GL_POLYGON_OFFSET_FILL);//0]
799 const TGLDisableGuard lightGuard(GL_LIGHTING);//[2-2]
800 glColor3d(0., 0., 0.);
801 glPolygonMode(GL_FRONT, GL_LINE);//[3
802
803 const TGLEnableGuard blendGuard(GL_BLEND);
804 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
805 const TGLEnableGuard smoothGuard(GL_LINE_SMOOTH);
806 glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
807
808 for(Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {
809 for(Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {
810 Double_t zMin = legoR + (fMinZ - fCoord->GetZRange().first) / rRange * sc;
811 Double_t zMax = legoR + (fHist->GetBinContent(ir, jr) - fCoord->GetZRange().first) / rRange * sc;
812 if (zMin > zMax)
813 std::swap(zMin, zMax);
814
815 points[0][0] = fCosSinTableX[i].first * zMin;
816 points[0][1] = fCosSinTableX[i].second * zMin;
817 points[1][0] = fCosSinTableX[i].first * zMax;
818 points[1][1] = fCosSinTableX[i].second * zMax;
819 points[2][0] = fCosSinTableX[i + 1].first * zMax;
820 points[2][1] = fCosSinTableX[i + 1].second * zMax;
821 points[3][0] = fCosSinTableX[i + 1].first * zMin;
822 points[3][1] = fCosSinTableX[i + 1].second * zMin;
823 Rgl::DrawTrapezoid(points, fYEdges[j].first, fYEdges[j].second);
824 }
825 }
826
827 glPolygonMode(GL_FRONT, GL_FILL);//3]
828 }
829
830 if(!fSelectionPass && fDrawPalette)
831 DrawPalette();
832}
833
834////////////////////////////////////////////////////////////////////////////////
835///Lego in spherical system.
836
837void TGLLegoPainter::DrawLegoSpherical()const
838{
839 const Int_t nX = fCosSinTableX.size() - 1;
840 const Int_t nY = fCosSinTableY.size() - 1;
841 const Double_t rRange = fCoord->GetZLength();
842 Double_t legoR = gStyle->GetLegoInnerR();
843 if (legoR > 1. || legoR < 0.)
844 legoR = 0.5;
845
846 if (!fSelectionPass) {
847 SetLegoColor();
848 glEnable(GL_POLYGON_OFFSET_FILL);
849 glPolygonOffset(1.f, 1.f);
850 }
851
852 Double_t points[8][3] = {};
853 const Double_t sc = 1 - legoR;
854
855 if (fLegoType == kColorLevel && !fSelectionPass) {
856 if (!PreparePalette()) {
857 fLegoType = kColorSimple;
858 fDrawPalette = kFALSE;
859 } else
860 fPalette.EnableTexture(GL_MODULATE);
861 }
862
863 if (fSelectionPass && fHighColor)
864 Rgl::ObjectIDToColor(fSelectionBase, kTRUE);
865
866 for(Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {
867 for(Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {
868 Double_t zMin = legoR + (fMinZ - fCoord->GetZRange().first) / rRange * sc;
869 Double_t zMax = legoR + (fHist->GetBinContent(ir, jr) - fCoord->GetZRange().first) / rRange * sc;
870 if (zMin > zMax)
871 std::swap(zMin, zMax);
872
873 points[4][0] = zMin * fCosSinTableY[j].second * fCosSinTableX[i].first;
874 points[4][1] = zMin * fCosSinTableY[j].second * fCosSinTableX[i].second;
875 points[4][2] = zMin * fCosSinTableY[j].first;
876 points[5][0] = zMin * fCosSinTableY[j].second * fCosSinTableX[i + 1].first;
877 points[5][1] = zMin * fCosSinTableY[j].second * fCosSinTableX[i + 1].second;
878 points[5][2] = zMin * fCosSinTableY[j].first;
879 points[6][0] = zMax * fCosSinTableY[j].second * fCosSinTableX[i + 1].first;
880 points[6][1] = zMax * fCosSinTableY[j].second * fCosSinTableX[i + 1].second;
881 points[6][2] = zMax * fCosSinTableY[j].first;
882 points[7][0] = zMax * fCosSinTableY[j].second * fCosSinTableX[i].first;
883 points[7][1] = zMax * fCosSinTableY[j].second * fCosSinTableX[i].second;
884 points[7][2] = zMax * fCosSinTableY[j].first;
885 points[0][0] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i].first;
886 points[0][1] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i].second;
887 points[0][2] = zMin * fCosSinTableY[j + 1].first;
888 points[1][0] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].first;
889 points[1][1] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].second;
890 points[1][2] = zMin * fCosSinTableY[j + 1].first;
891 points[2][0] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].first;
892 points[2][1] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].second;
893 points[2][2] = zMax * fCosSinTableY[j + 1].first;
894 points[3][0] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i].first;
895 points[3][1] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i].second;
896 points[3][2] = zMax * fCosSinTableY[j + 1].first;
897
898 const Int_t binID = fSelectionBase + i * fCoord->GetNYBins() + j;
899
900 if (fSelectionPass && !fHighColor)
901 Rgl::ObjectIDToColor(binID, kFALSE);
902 else if(!fHighColor && fSelectedPart == binID)
903 glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gOrangeEmission);
904 if (fLegoType == kColorLevel && !fSelectionPass)
905 Rgl::DrawTrapezoidTextured(points, fPalette.GetTexCoord(fMinZ),
906 fPalette.GetTexCoord(fHist->GetBinContent(ir, jr)));
907 else
908 Rgl::DrawTrapezoid(points);
909
910 if(!fHighColor && fSelectedPart == binID)
911 glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gNullEmission);
912 }
913 }
914
915 if (fLegoType == kColorLevel && !fSelectionPass)
916 fPalette.DisableTexture();
917
918 //Draw outlines.
919 if (!fSelectionPass) {
920 glDisable(GL_POLYGON_OFFSET_FILL);//0]
921 const TGLDisableGuard lightGuard(GL_LIGHTING);//[2-2]
922 glColor3d(0., 0., 0.);
923 glPolygonMode(GL_FRONT, GL_LINE);//[3
924 const TGLEnableGuard blendGuard(GL_BLEND);
925 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
926 const TGLEnableGuard smoothGuard(GL_LINE_SMOOTH);
927 glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
928
929 for(Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {
930 for(Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {
931 Double_t zMin = legoR + (fMinZ - fCoord->GetZRange().first) / rRange * sc;
932 Double_t zMax = legoR + (fHist->GetBinContent(ir, jr) - fCoord->GetZRange().first) / rRange * sc;
933 if (zMin > zMax)
934 std::swap(zMin, zMax);
935
936 points[4][0] = zMin * fCosSinTableY[j].second * fCosSinTableX[i].first;
937 points[4][1] = zMin * fCosSinTableY[j].second * fCosSinTableX[i].second;
938 points[4][2] = zMin * fCosSinTableY[j].first;
939 points[5][0] = zMin * fCosSinTableY[j].second * fCosSinTableX[i + 1].first;
940 points[5][1] = zMin * fCosSinTableY[j].second * fCosSinTableX[i + 1].second;
941 points[5][2] = zMin * fCosSinTableY[j].first;
942 points[6][0] = zMax * fCosSinTableY[j].second * fCosSinTableX[i + 1].first;
943 points[6][1] = zMax * fCosSinTableY[j].second * fCosSinTableX[i + 1].second;
944 points[6][2] = zMax * fCosSinTableY[j].first;
945 points[7][0] = zMax * fCosSinTableY[j].second * fCosSinTableX[i].first;
946 points[7][1] = zMax * fCosSinTableY[j].second * fCosSinTableX[i].second;
947 points[7][2] = zMax * fCosSinTableY[j].first;
948 points[0][0] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i].first;
949 points[0][1] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i].second;
950 points[0][2] = zMin * fCosSinTableY[j + 1].first;
951 points[1][0] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].first;
952 points[1][1] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].second;
953 points[1][2] = zMin * fCosSinTableY[j + 1].first;
954 points[2][0] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].first;
955 points[2][1] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].second;
956 points[2][2] = zMax * fCosSinTableY[j + 1].first;
957 points[3][0] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i].first;
958 points[3][1] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i].second;
959 points[3][2] = zMax * fCosSinTableY[j + 1].first;
960 Rgl::DrawTrapezoid(points);
961 }
962 }
963
964 glPolygonMode(GL_FRONT, GL_FILL);//3]
965 }
966
967 if(!fSelectionPass && fDrawPalette)
968 DrawPalette();
969}
970
971////////////////////////////////////////////////////////////////////////////////
972///Set lego's color.
973
974void TGLLegoPainter::SetLegoColor()const
975{
976 Float_t diffColor[] = {0.8f, 0.8f, 0.8f, 0.15f};
977
978 if (fLegoType != kColorLevel && fHist->GetFillColor() != kWhite)
979 if (const TColor *c = gROOT->GetColor(fHist->GetFillColor()))
980 c->GetRGB(diffColor[0], diffColor[1], diffColor[2]);
981
982 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffColor);
983 const Float_t specColor[] = {1.f, 1.f, 1.f, 1.f};
984 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specColor);
985 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 70.f);
986}
987
988////////////////////////////////////////////////////////////////////////////////
989///XOZ plane parallel section.
990
991void TGLLegoPainter::DrawSectionXOZ()const
992{
993 Int_t binY = -1;
994
995 for (Int_t i = 0, e = fYEdges.size(); i < e; ++i) {
996 if (fYEdges[i].first <= fXOZSectionPos && fXOZSectionPos <= fYEdges[i].second) {
997 binY = i;
998 break;
999 }
1000 }
1001
1002 if (binY >= 0) {
1003 binY += fCoord->GetFirstYBin();
1004 glColor3d(1., 0., 0.);
1005 glLineWidth(3.f);
1006 //Draw 2d hist on the profile's plane.
1007 for (UInt_t i = 0, ir = fCoord->GetFirstXBin(), e = fXEdges.size(); i < e; ++i, ++ir) {
1008 Double_t zMax = fHist->GetBinContent(Int_t(ir), binY);
1009 if (!ClampZ(zMax))
1010 continue;
1011
1012 glBegin(GL_LINE_LOOP);
1013 glVertex3d(fXEdges[i].first, fXOZSectionPos, fMinZ);
1014 glVertex3d(fXEdges[i].first, fXOZSectionPos, zMax);
1015 glVertex3d(fXEdges[i].second, fXOZSectionPos, zMax);
1016 glVertex3d(fXEdges[i].second, fXOZSectionPos, fMinZ);
1017 glEnd();
1018 }
1019
1020 glLineWidth(1.f);
1021 }
1022}
1023
1024////////////////////////////////////////////////////////////////////////////////
1025///YOZ plane parallel section.
1026
1027void TGLLegoPainter::DrawSectionYOZ()const
1028{
1029 Int_t binX = -1;
1030
1031 for (Int_t i = 0, e = fXEdges.size(); i < e; ++i) {
1032 if (fXEdges[i].first <= fYOZSectionPos && fYOZSectionPos <= fXEdges[i].second) {
1033 binX = i;
1034 break;
1035 }
1036 }
1037
1038 if (binX >= 0) {
1039 binX += fCoord->GetFirstXBin();//fBinsX.first;
1040 glColor3d(1., 0., 0.);
1041 glLineWidth(3.f);
1042 //Draw 2d hist on the profile's plane.
1043 for (UInt_t i = 0, ir = fCoord->GetFirstYBin(), e = fYEdges.size(); i < e; ++i, ++ir) {
1044 Double_t zMax = fHist->GetBinContent(binX, ir);
1045 if (!ClampZ(zMax))
1046 continue;
1047
1048 glBegin(GL_LINE_LOOP);
1049 glVertex3d(fYOZSectionPos, fYEdges[i].first, fMinZ);
1050 glVertex3d(fYOZSectionPos, fYEdges[i].first, zMax);
1051 glVertex3d(fYOZSectionPos, fYEdges[i].second, zMax);
1052 glVertex3d(fYOZSectionPos, fYEdges[i].second, fMinZ);
1053 glEnd();
1054 }
1055
1056 glLineWidth(1.f);
1057 }
1058}
1059
1060////////////////////////////////////////////////////////////////////////////////
1061///Empty. No such sections for lego.
1062
1063void TGLLegoPainter::DrawSectionXOY()const
1064{
1065}
1066
1067////////////////////////////////////////////////////////////////////////////////
1068///Remove all sections and repaint.
1069
1070void TGLLegoPainter::ProcessEvent(Int_t event, Int_t /*px*/, Int_t py)
1071{
1072 const TGLVertex3 *frame = fBackBox.Get3DBox();
1073 if (event == kButton1Double && (fXOZSectionPos > frame[0].Y() || fYOZSectionPos > frame[0].X())) {
1074 fXOZSectionPos = frame[0].Y();
1075 fYOZSectionPos = frame[0].X();
1076 if (fBoxCut.IsActive())
1077 fBoxCut.TurnOnOff();
1078 //gGLManager->PaintSingleObject(this);
1079 if (!gVirtualX->IsCmdThread())
1080 gROOT->ProcessLineFast(Form("((TGLPlotPainter *)0x%zx)->Paint()", (size_t)this));
1081 else
1082 Paint();
1083 } else if (event == kKeyPress && (py == kKey_c || py == kKey_C)) {
1084 Info("ProcessEvent", "Box cut does not exist for lego");
1085 }
1086}
1087
1088////////////////////////////////////////////////////////////////////////////////
1089///Clamp z value.
1090
1091Bool_t TGLLegoPainter::ClampZ(Double_t &zVal)const
1092{
1093 if (fCoord->GetZLog())
1094 if (zVal <= 0.)
1095 return kFALSE;
1096 else
1097 zVal = TMath::Log10(zVal) * fCoord->GetZScale();
1098 else
1099 zVal *= fCoord->GetZScale();
1100
1101 const TGLVertex3 *frame = fBackBox.Get3DBox();
1102
1103 if (zVal > frame[4].Z())
1104 zVal = frame[4].Z();
1105 else if (zVal < frame[0].Z())
1106 zVal = frame[0].Z();
1107
1108 return kTRUE;
1109}
1110
1111////////////////////////////////////////////////////////////////////////////////
1112///Initialize color palette.
1113
1114Bool_t TGLLegoPainter::PreparePalette()const
1115{
1116 if(fMinMaxVal.first == fMinMaxVal.second)
1117 return kFALSE;//must be std::abs(fMinMaxVal.second - fMinMaxVal.first) < ...
1118
1119 //User-defined contours are disabled, to be fixed in a future.
1120 if (fHist->TestBit(TH1::kUserContour))
1121 fHist->ResetBit(TH1::kUserContour);
1122
1123 UInt_t paletteSize = gStyle->GetNumberContours();
1124 if (!paletteSize)
1125 paletteSize = 20;
1126
1127 return fPalette.GeneratePalette(paletteSize, Rgl::Range_t(fMinZ, fMinMaxVal.second));
1128}
1129
1130////////////////////////////////////////////////////////////////////////////////
1131///Draw. Palette.
1132///Originally, fCamera was never null.
1133///It can be a null now because of gl-viewer.
1134
1135void TGLLegoPainter::DrawPalette()const
1136{
1137 if (!fCamera) {
1138 //Thank you, gl-viewer!
1139 return;
1140 }
1141
1142 Rgl::DrawPalette(fCamera, fPalette);
1143
1144 glFinish();
1145
1146 fCamera->SetCamera();
1147 fCamera->Apply(fPadPhi, fPadTheta);
1148}
1149
1150////////////////////////////////////////////////////////////////////////////////
1151///Draw. Palette. Axis.
1152
1153void TGLLegoPainter::DrawPaletteAxis()const
1154{
1155 gVirtualX->SetDrawMode(TVirtualX::kCopy);//TCanvas by default sets in kInverse
1156 Rgl::DrawPaletteAxis(fCamera, fMinMaxVal, fCoord->GetCoordType() == kGLCartesian ? fCoord->GetZLog() : kFALSE);
1157}
kKeyPress
@ kKeyPress
Definition Buttons.h:20
kButton1Double
@ kButton1Double
Definition Buttons.h:24
GL_TRUE
#define GL_TRUE
Definition GL_glu.h:262
GL_FALSE
#define GL_FALSE
Definition GL_glu.h:261
GL_LINE_LOOP
#define GL_LINE_LOOP
Definition GL_glu.h:285
kKey_C
@ kKey_C
Definition KeySymbols.h:128
kKey_c
@ kKey_c
Definition KeySymbols.h:160
c
#define c(i)
Definition RSha256.hxx:101
e
#define e(i)
Definition RSha256.hxx:103
Bool_t
bool Bool_t
Definition RtypesCore.h:63
Int_t
int Int_t
Definition RtypesCore.h:45
Ssiz_t
int Ssiz_t
Definition RtypesCore.h:67
Char_t
char Char_t
Definition RtypesCore.h:37
UInt_t
unsigned int UInt_t
Definition RtypesCore.h:46
Float_t
float Float_t
Definition RtypesCore.h:57
kFALSE
constexpr Bool_t kFALSE
Definition RtypesCore.h:101
Double_t
double Double_t
Definition RtypesCore.h:59
kNPOS
constexpr Ssiz_t kNPOS
Definition RtypesCore.h:124
kTRUE
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
ClassImp
#define ClassImp(name)
Definition Rtypes.h:377
kWhite
@ kWhite
Definition Rtypes.h:65
X
#define X(type, name)
Info
void Info(const char *location, const char *msgfmt,...)
Use this function for informational messages.
Definition TError.cxx:218
kGLSpherical
@ kGLSpherical
Definition TGLUtil.h:47
kGLCylindrical
@ kGLCylindrical
Definition TGLUtil.h:46
kGLPolar
@ kGLPolar
Definition TGLUtil.h:45
kGLCartesian
@ kGLCartesian
Definition TGLUtil.h:44
option
Option_t Option_t option
Definition TGWin32VirtualXProxy.cxx:44
angle
Option_t Option_t TPoint TPoint angle
Definition TGWin32VirtualXProxy.cxx:68
points
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t points
Definition TGWin32VirtualXProxy.cxx:148
py
Int_t py
Definition TGraphAsymmErrors.cxx:1302
i
Int_t i
Definition TGraphAsymmErrors.cxx:1306
gROOT
#define gROOT
Definition TROOT.h:414
Form
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition TString.cxx:2489
gStyle
R__EXTERN TStyle * gStyle
Definition TStyle.h:433
gVirtualX
#define gVirtualX
Definition TVirtualX.h:337
TColor
The color creation and management class.
Definition TColor.h:21
TGLLegoPainter
Plot-painter implementing LEGO rendering of TH2 histograms in cartesian, polar, cylindrical and spher...
Definition TGLLegoPainter.h:31
TGLLegoPainter::InitGeometryCartesian
Bool_t InitGeometryCartesian()
Geometry for lego in cartesian coords.
Definition TGLLegoPainter.cxx:98
TGLLegoPainter::PreparePalette
Bool_t PreparePalette() const
Initialize color palette.
Definition TGLLegoPainter.cxx:1114
TGLLegoPainter::DrawSectionXOZ
void DrawSectionXOZ() const override
XOZ plane parallel section.
Definition TGLLegoPainter.cxx:991
TGLLegoPainter::DrawSectionXOY
void DrawSectionXOY() const override
Empty. No such sections for lego.
Definition TGLLegoPainter.cxx:1063
TGLLegoPainter::DrawLegoSpherical
void DrawLegoSpherical() const
Lego in spherical system.
Definition TGLLegoPainter.cxx:837
TGLLegoPainter::fXEdges
std::vector< Rgl::Range_t > fXEdges
Definition TGLLegoPainter.h:44
TGLLegoPainter::StartPan
void StartPan(Int_t px, Int_t py) override
User clicks on a lego with middle mouse button (middle for pad).
Definition TGLLegoPainter.cxx:382
TGLLegoPainter::InitGeometryCylindrical
Bool_t InitGeometryCylindrical()
Geometry for lego in cylindrical coords.
Definition TGLLegoPainter.cxx:261
TGLLegoPainter::AddOption
void AddOption(const TString &stringOption) override
Parse additional options.
Definition TGLLegoPainter.cxx:434
TGLLegoPainter::fPalette
TGLLevelPalette fPalette
Definition TGLLegoPainter.h:54
TGLLegoPainter::InitGL
void InitGL() const override
Initialize some gl state variables.
Definition TGLLegoPainter.cxx:466
TGLLegoPainter::GetPlotInfo
char * GetPlotInfo(Int_t px, Int_t py) override
Obtain bin's info (i, j, value).
Definition TGLLegoPainter.cxx:51
TGLLegoPainter::DrawLegoPolar
void DrawLegoPolar() const
Lego in polar system.
Definition TGLLegoPainter.cxx:632
TGLLegoPainter::DrawSectionYOZ
void DrawSectionYOZ() const override
YOZ plane parallel section.
Definition TGLLegoPainter.cxx:1027
TGLLegoPainter::Pan
void Pan(Int_t px, Int_t py) override
Move lego or section.
Definition TGLLegoPainter.cxx:393
TGLLegoPainter::ClampZ
Bool_t ClampZ(Double_t &zVal) const
Clamp z value.
Definition TGLLegoPainter.cxx:1091
TGLLegoPainter::InitGeometrySpherical
Bool_t InitGeometrySpherical()
Geometry for lego in spherical coords.
Definition TGLLegoPainter.cxx:324
TGLLegoPainter::DrawPlot
void DrawPlot() const override
Select method corresponding to coordinate system.
Definition TGLLegoPainter.cxx:493
TGLLegoPainter::fQuadric
TGLQuadric fQuadric
Definition TGLLegoPainter.h:51
TGLLegoPainter::TGLLegoPainter
TGLLegoPainter(const TGLLegoPainter &)
TGLLegoPainter::DrawPalette
void DrawPalette() const
Draw.
Definition TGLLegoPainter.cxx:1135
TGLLegoPainter::DrawLegoCartesian
void DrawLegoCartesian() const
Lego in cartesian system.
Definition TGLLegoPainter.cxx:514
TGLLegoPainter::SetLegoColor
void SetLegoColor() const
Set lego's color.
Definition TGLLegoPainter.cxx:974
TGLLegoPainter::fYEdges
std::vector< Rgl::Range_t > fYEdges
Definition TGLLegoPainter.h:45
TGLLegoPainter::fCosSinTableX
std::vector< CosSin_t > fCosSinTableX
Definition TGLLegoPainter.h:48
TGLLegoPainter::fMinMaxVal
Rgl::Range_t fMinMaxVal
Definition TGLLegoPainter.h:42
TGLLegoPainter::DeInitGL
void DeInitGL() const override
Return some gl states to original values.
Definition TGLLegoPainter.cxx:481
TGLLegoPainter::DrawLegoCylindrical
void DrawLegoCylindrical() const
Lego in cylindrical system.
Definition TGLLegoPainter.cxx:729
TGLLegoPainter::fCosSinTableY
std::vector< CosSin_t > fCosSinTableY
Definition TGLLegoPainter.h:49
TGLLegoPainter::InitGeometryPolar
Bool_t InitGeometryPolar()
Geometry for lego in polar coords.
Definition TGLLegoPainter.cxx:201
TGLLegoPainter::ProcessEvent
void ProcessEvent(Int_t event, Int_t px, Int_t py) override
Remove all sections and repaint.
Definition TGLLegoPainter.cxx:1070
TGLLegoPainter::fLegoType
ELegoType fLegoType
Definition TGLLegoPainter.h:40
TGLLegoPainter::InitGeometry
Bool_t InitGeometry() override
Select method.
Definition TGLLegoPainter.cxx:76
TGLLegoPainter::DrawPaletteAxis
void DrawPaletteAxis() const override
Draw. Palette. Axis.
Definition TGLLegoPainter.cxx:1153
TGLPlotCamera
Camera for TGLPlotPainter and sub-classes.
Definition TGLPlotCamera.h:22
TGLPlotCoordinates
Helper class for plot-painters holding information about axis ranges, numbers of bins and flags if ce...
Definition TGLPlotPainter.h:310
TGLPlotPainter::DrawSections
void DrawSections() const
Draw sections (if any).
Definition TGLPlotPainter.cxx:441
TGLPlotPainter::TGLPlotPainter
TGLPlotPainter(TH1 *hist, TGLPlotCamera *camera, TGLPlotCoordinates *coord, Bool_t xoySelectable, Bool_t xozSelectable, Bool_t yozSelectable)
TGLPlotPainter's ctor.
Definition TGLPlotPainter.cxx:50
TGLPlotPainter::fZLevels
std::vector< Double_t > fZLevels
Definition TGLPlotPainter.h:210
TGLPlotPainter::fXOYSectionPos
Double_t fXOYSectionPos
Definition TGLPlotPainter.h:206
TGLPlotPainter::RestoreModelviewMatrix
void RestoreModelviewMatrix() const
Definition TGLPlotPainter.cxx:602
TGLPlotPainter::fXOZSectionPos
Double_t fXOZSectionPos
Definition TGLPlotPainter.h:204
TGLPlotPainter::fCoord
TGLPlotCoordinates * fCoord
Definition TGLPlotPainter.h:196
TGLPlotPainter::Paint
void Paint() override
Draw lego/surf/whatever you can.
Definition TGLPlotPainter.cxx:150
TGLPlotPainter::fBackBox
TGLPlotBox fBackBox
Definition TGLPlotPainter.h:207
TGLPlotPainter::SaveProjectionMatrix
void SaveProjectionMatrix() const
Definition TGLPlotPainter.cxx:594
TGLPlotPainter::SaveModelviewMatrix
void SaveModelviewMatrix() const
Definition TGLPlotPainter.cxx:586
TGLPlotPainter::MoveSection
void MoveSection(Int_t px, Int_t py)
Create dynamic profile using selected plane.
Definition TGLPlotPainter.cxx:369
TGLPlotPainter::fCamera
TGLPlotCamera * fCamera
Definition TGLPlotPainter.h:197
TGLPlotPainter::RestoreProjectionMatrix
void RestoreProjectionMatrix() const
Definition TGLPlotPainter.cxx:610
TGLPlotPainter::fYOZSectionPos
Double_t fYOZSectionPos
Definition TGLPlotPainter.h:205
TGLVertex3
3 component (x/y/z) vertex class.
Definition TGLUtil.h:84
TGLVertex3::X
Double_t X() const
Definition TGLUtil.h:119
TGLVertex3::Z
Double_t Z() const
Definition TGLUtil.h:123
TGLVertex3::Y
Double_t Y() const
Definition TGLUtil.h:121
TH1
TH1 is the base class of all histogram classes in ROOT.
Definition TH1.h:59
TH1::kUserContour
@ kUserContour
User specified contour levels.
Definition TH1.h:166
TString
Basic string class.
Definition TString.h:139
Rgl::DrawTrapezoid
void DrawTrapezoid(const Double_t ver[][2], Double_t zMin, Double_t zMax, Bool_t color=kTRUE)
Definition TGLUtil.cxx:3357
Rgl::DrawTrapezoidTextured
void DrawTrapezoidTextured(const Double_t ver[][2], Double_t zMin, Double_t zMax, Double_t tMin, Double_t tMax)
In polar coordinates, box became trapezoid.
Definition TGLUtil.cxx:3427
Rgl::gNullEmission
const Float_t gNullEmission[]
Definition TGLUtil.cxx:2856
Rgl::ObjectIDToColor
void ObjectIDToColor(Int_t objectID, Bool_t highColor)
Object id encoded as rgb triplet.
Definition TGLUtil.cxx:2900
Rgl::SetZLevels
void SetZLevels(TAxis *zAxis, Double_t zMin, Double_t zMax, Double_t zScale, std::vector< Double_t > &zLevels)
Definition TGLUtil.cxx:3829
Rgl::DrawPalette
void DrawPalette(const TGLPlotCamera *camera, const TGLLevelPalette &palette)
Draw. Palette.
Definition TGLPlotPainter.cxx:2114
Rgl::DrawPaletteAxis
void DrawPaletteAxis(const TGLPlotCamera *camera, const Range_t &minMax, Bool_t logZ)
Definition TGLPlotPainter.cxx:2220
Rgl::DrawTrapezoidTextured2
void DrawTrapezoidTextured2(const Double_t ver[][2], Double_t zMin, Double_t zMax, Double_t tMin, Double_t tMax)
In polar coordinates, box became trapezoid.
Definition TGLUtil.cxx:3504
Rgl::DrawCylinder
void DrawCylinder(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:3253
Rgl::DrawError
void DrawError(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax, Double_t zMin, Double_t zMax)
Definition TGLUtil.cxx:3307
Rgl::Range_t
std::pair< Double_t, Double_t > Range_t
Definition TGLUtil.h:1202
Rgl::DrawBoxFront
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's bar as a 3d box.
Definition TGLUtil.cxx:3016
Rgl::DrawBoxFrontTextured
void DrawBoxFrontTextured(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMax, Double_t zMin, Double_t zMax, Double_t tMin, Double_t tMax, Int_t front)
Draws lego's bar as a 3d box LULULULU.
Definition TGLUtil.cxx:3143
Rgl::gOrangeEmission
const Float_t gOrangeEmission[]
Definition TGLUtil.cxx:2853
TMath::Max
Short_t Max(Short_t a, Short_t b)
Returns the largest of a and b.
Definition TMathBase.h:250
TMath::Min
Short_t Min(Short_t a, Short_t b)
Returns the smallest of a and b.
Definition TMathBase.h:198
TMath::Cos
Double_t Cos(Double_t)
Returns the cosine of an angle of x radians.
Definition TMath.h:594
TMath::Pi
constexpr Double_t Pi()
Definition TMath.h:37
TMath::Sin
Double_t Sin(Double_t)
Returns the sine of an angle of x radians.
Definition TMath.h:588
TMath::Log10
Double_t Log10(Double_t x)
Returns the common (base-10) logarithm of x.
Definition TMath.h:762
TMath::TwoPi
constexpr Double_t TwoPi()
Definition TMath.h:44