doc/v616/TGLLegoPainter_8cxx_source.html

// @(#)root/gl:$Id$

// Author:  Timur Pocheptsov  14/06/2006


/*************************************************************************

 * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers.               *

 * All rights reserved.                                                  *

 *                                                                       *

 * For the licensing terms see $ROOTSYS/LICENSE.                         *

 * For the list of contributors see $ROOTSYS/README/CREDITS.             *

 *************************************************************************/

#include <algorithm>

#include <cctype>


#include "KeySymbols.h"

#include "TVirtualX.h"

#include "Buttons.h"

#include "TString.h"

#include "TColor.h"

#include "TROOT.h"

#include "TClass.h"

#include "TStyle.h"

#include "TAxis.h"

#include "TMath.h"

#include "TH1.h"


#include "TGLLegoPainter.h"

#include "TGLPlotCamera.h"

#include "TGLIncludes.h"


/** \class TGLLegoPainter

\ingroup opengl

Plot-painter implementing LEGO rendering of TH2 histograms in

cartesian, polar, cylindrical and spherical coordinates.

*/


ClassImp(TGLLegoPainter);


////////////////////////////////////////////////////////////////////////////////

///Ctor.


TGLLegoPainter::TGLLegoPainter(TH1 *hist, TGLPlotCamera *cam, TGLPlotCoordinates *coord)

                  : TGLPlotPainter(hist, cam, coord, kFALSE, kTRUE, kTRUE),

                    fLegoType(kColorSimple),

                    fMinZ(0.),

                    fDrawErrors(kFALSE)

{

}


////////////////////////////////////////////////////////////////////////////////

///Obtain bin's info (i, j, value).


char *TGLLegoPainter::GetPlotInfo(Int_t /*px*/, Int_t /*py*/)

{

   fBinInfo = "";


   if (fSelectedPart) {

      if (fSelectedPart < fSelectionBase) {

         if (fHist->Class())

            fBinInfo += fHist->Class()->GetName();

         fBinInfo += "::";

         fBinInfo += fHist->GetName();

      } else if (!fHighColor) {

         const Int_t binI = (fSelectedPart - fSelectionBase) / fCoord->GetNYBins() + fCoord->GetFirstXBin();

         const Int_t binJ = (fSelectedPart - fSelectionBase) % fCoord->GetNYBins() + fCoord->GetFirstYBin();

         fBinInfo.Form("(binx = %d; biny = %d; binc = %f)", binI, binJ,

                       fHist->GetBinContent(binI, binJ));

      } else

         fBinInfo = "Switch to true-color mode to obtain correct info";

   }


   return (Char_t *)fBinInfo.Data();

}


////////////////////////////////////////////////////////////////////////////////

///Select method.


Bool_t TGLLegoPainter::InitGeometry()

{

   Bool_t ret = kFALSE;

   switch (fCoord->GetCoordType()) {

   case kGLCartesian:

      ret = InitGeometryCartesian(); break;

   case kGLPolar:

      ret = InitGeometryPolar(); break;

   case kGLCylindrical:

      ret = InitGeometryCylindrical(); break;

   case kGLSpherical:

      ret = InitGeometrySpherical(); break;

   default:

      return kFALSE;

   }

   if (ret && fCamera) fCamera->SetViewVolume(fBackBox.Get3DBox());

   return ret;

}


////////////////////////////////////////////////////////////////////////////////

///Geometry for lego in cartesian coords.


Bool_t TGLLegoPainter::InitGeometryCartesian()

{

   if (!fCoord->SetRanges(fHist, fDrawErrors, kFALSE))

      return kFALSE;


   fBackBox.SetPlotBox(fCoord->GetXRangeScaled(), fCoord->GetYRangeScaled(), fCoord->GetZRangeScaled());


   //Find bin edges

   const Int_t nX = fCoord->GetNXBins();

   const Double_t barWidth = fHist->GetBarWidth(), barOffset = fHist->GetBarOffset();

   const TGLVertex3 *frame = fBackBox.Get3DBox();

   fXEdges.resize(nX);


   if (fCoord->GetXLog()) {

      for (Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {

         const Double_t xWidth = fXAxis->GetBinWidth(ir);

         Double_t low = fXAxis->GetBinLowEdge(ir) + xWidth * barOffset;

         fXEdges[i].first  = TMath::Log10(low) * fCoord->GetXScale();

         fXEdges[i].second = TMath::Log10(low + xWidth * barWidth) * fCoord->GetXScale();

         if (fXEdges[i].second > frame[1].X())

            fXEdges[i].second = frame[1].X();

         if (fXEdges[i].first < frame[0].X())

            fXEdges[i].first = frame[0].X();

         if (fXEdges[i].second < frame[0].X())

            fXEdges[i].second = frame[0].X();

      }

   } else {

      for (Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {

         const Double_t xWidth = fXAxis->GetBinWidth(ir);

         fXEdges[i].first  = (fXAxis->GetBinLowEdge(ir) + xWidth * barOffset) * fCoord->GetXScale();

         fXEdges[i].second = fXEdges[i].first + xWidth * barWidth * fCoord->GetXScale();

         if (fXEdges[i].second > frame[1].X())

            fXEdges[i].second = frame[1].X();

         if (fXEdges[i].first < frame[0].X())

            fXEdges[i].first = frame[0].X();

         if (fXEdges[i].second < frame[0].X())

            fXEdges[i].second = frame[0].X();

      }

   }


   const Int_t nY = fCoord->GetNYBins();

   fYEdges.resize(nY);


   if (fCoord->GetYLog()) {

      for (Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {

         const Double_t yWidth = fYAxis->GetBinWidth(jr);

         Double_t low = fYAxis->GetBinLowEdge(jr) + yWidth * barOffset;

         fYEdges[j].first  = TMath::Log10(low) * fCoord->GetYScale();

         fYEdges[j].second = TMath::Log10(low + yWidth * barWidth) * fCoord->GetYScale();

         if (fYEdges[j].second > frame[2].Y())

            fYEdges[j].second = frame[2].Y();

         if (fYEdges[j].first < frame[0].Y())

            fYEdges[j].first = frame[0].Y();

         if (fYEdges[j].second < frame[0].Y())

            fYEdges[j].second = frame[0].Y();

      }

   } else {

      for (Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {

         const Double_t yWidth = fYAxis->GetBinWidth(jr);

         fYEdges[j].first  = (fYAxis->GetBinLowEdge(jr) + yWidth * barOffset) * fCoord->GetYScale();

         fYEdges[j].second = fYEdges[j].first + yWidth * barWidth * fCoord->GetYScale();

         if (fYEdges[j].second > frame[2].Y())

            fYEdges[j].second = frame[2].Y();

         if (fYEdges[j].first < frame[0].Y())

            fYEdges[j].first = frame[0].Y();

         if (fYEdges[j].second < frame[0].Y())

            fYEdges[j].second = frame[0].Y();

      }

   }


   fMinZ = frame[0].Z();

   if (fMinZ < 0.)

      frame[4].Z() > 0. ? fMinZ = 0. : fMinZ = frame[4].Z();


   if (fCoord->Modified()) {

      fUpdateSelection = kTRUE;

      fXOZSectionPos = frame[0].Y();

      fYOZSectionPos = frame[0].X();

      fXOYSectionPos = frame[0].Z();

      fCoord->ResetModified();

      Rgl::SetZLevels(fZAxis, fCoord->GetZRange().first, fCoord->GetZRange().second, fCoord->GetZScale(), fZLevels);

   }


   fMinMaxVal.first  = fHist->GetBinContent(fCoord->GetFirstXBin(), fCoord->GetFirstYBin());

   fMinMaxVal.second = fMinMaxVal.first;


   for (Int_t i = fCoord->GetFirstXBin(), e = fCoord->GetLastXBin(); i <= e; ++i) {

      for (Int_t j = fCoord->GetFirstYBin(), e1 = fCoord->GetLastYBin(); j <= e1; ++j) {

         Double_t val = fHist->GetBinContent(i, j);

         fMinMaxVal.first  = TMath::Min(fMinMaxVal.first, val);

         fMinMaxVal.second = TMath::Max(fMinMaxVal.second, val);

      }

   }


   ClampZ(fMinMaxVal.first);

   ClampZ(fMinMaxVal.second);


   return kTRUE;

}


////////////////////////////////////////////////////////////////////////////////

///Geometry for lego in polar coords.


Bool_t TGLLegoPainter::InitGeometryPolar()

{

   if (!fCoord->SetRanges(fHist, kFALSE, kFALSE))

      return kFALSE;


   fBackBox.SetPlotBox(fCoord->GetXRangeScaled(), fCoord->GetYRangeScaled(), fCoord->GetZRangeScaled());


   if (fCoord->Modified()) {

      fUpdateSelection = kTRUE;

      fCoord->ResetModified();

   }


   const Int_t nY = fCoord->GetNYBins();//yBins.second - yBins.first + 1;

   fYEdges.resize(nY);


   for (Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {

      fYEdges[j].first = ((fYAxis->GetBinLowEdge(jr)) - fCoord->GetYRange().first) /

                           fCoord->GetYLength() * fCoord->GetYScale();

      fYEdges[j].second = ((fYAxis->GetBinUpEdge(jr)) - fCoord->GetYRange().first) /

                           fCoord->GetYLength() * fCoord->GetYScale();

   }


   const Int_t nX = fCoord->GetNXBins();

   fCosSinTableX.resize(nX + 1);

   const Double_t fullAngle = fXAxis->GetXmax() - fXAxis->GetXmin();

   const Double_t phiLow = fXAxis->GetXmin();

   Double_t angle = 0;

   for (Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {

      angle = (fXAxis->GetBinLowEdge(ir) - phiLow) / fullAngle * TMath::TwoPi();

      fCosSinTableX[i].first  = TMath::Cos(angle);

      fCosSinTableX[i].second = TMath::Sin(angle);

   }

   angle = (fXAxis->GetBinUpEdge(fCoord->GetLastXBin()) - phiLow) / fullAngle * TMath::TwoPi();

   fCosSinTableX[nX].first  = TMath::Cos(angle);

   fCosSinTableX[nX].second = TMath::Sin(angle);


   fMinZ = fBackBox.Get3DBox()[0].Z();

   if (fMinZ < 0.)

      fBackBox.Get3DBox()[4].Z() > 0. ? fMinZ = 0. : fMinZ = fBackBox.Get3DBox()[4].Z();


   fMinMaxVal.first  = fHist->GetBinContent(fCoord->GetFirstXBin(), fCoord->GetFirstYBin());

   fMinMaxVal.second = fMinMaxVal.first;


   for (Int_t i = fCoord->GetFirstXBin(), e = fCoord->GetLastXBin(); i <= e; ++i) {

      for (Int_t j = fCoord->GetFirstYBin(), e1 = fCoord->GetLastYBin(); j <= e1; ++j) {

         Double_t val = fHist->GetBinContent(i, j);

         fMinMaxVal.first  = TMath::Min(fMinMaxVal.first, val);

         fMinMaxVal.second = TMath::Max(fMinMaxVal.second, val);

      }

   }


   ClampZ(fMinMaxVal.first);

   ClampZ(fMinMaxVal.second);


   return kTRUE;

}


////////////////////////////////////////////////////////////////////////////////

///Geometry for lego in cylindrical coords.


Bool_t TGLLegoPainter::InitGeometryCylindrical()

{

   if (!fCoord->SetRanges(fHist, kFALSE, kFALSE))

      return kFALSE;


   fBackBox.SetPlotBox(fCoord->GetXRangeScaled(), fCoord->GetYRangeScaled(), fCoord->GetZRangeScaled());


   const Int_t nY = fCoord->GetNYBins();

   fYEdges.resize(nY);


   if (fCoord->GetYLog()) {

      for (Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {

         fYEdges[j].first  = TMath::Log10(fYAxis->GetBinLowEdge(jr)) * fCoord->GetYScale();

         fYEdges[j].second = TMath::Log10(fYAxis->GetBinUpEdge(jr))  * fCoord->GetYScale();

      }

   } else {

      for (Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {

         fYEdges[j].first  = fYAxis->GetBinLowEdge(jr) * fCoord->GetYScale();

         fYEdges[j].second = fYAxis->GetBinUpEdge(jr)  * fCoord->GetYScale();

      }

   }


   const Int_t nX = fCoord->GetNXBins();

   fCosSinTableX.resize(nX + 1);

   const Double_t fullAngle = fXAxis->GetXmax() - fXAxis->GetXmin();

   const Double_t phiLow    = fXAxis->GetXmin();

   Double_t angle = 0.;

   for (Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {

      angle = (fXAxis->GetBinLowEdge(ir) - phiLow) / fullAngle * TMath::TwoPi();

      fCosSinTableX[i].first  = TMath::Cos(angle);

      fCosSinTableX[i].second = TMath::Sin(angle);

   }

   angle = (fXAxis->GetBinUpEdge(fCoord->GetLastXBin()) - phiLow) / fullAngle * TMath::TwoPi();

   fCosSinTableX[nX].first  = TMath::Cos(angle);

   fCosSinTableX[nX].second = TMath::Sin(angle);


   if (fCoord->Modified()) {

      fUpdateSelection = kTRUE;

      fCoord->ResetModified();

   }


   fMinZ = fCoord->GetZRange().first;

   if (fMinZ < 0.)

      fCoord->GetZRange().second > 0. ? fMinZ = 0. : fMinZ = fCoord->GetZRange().second;


   fMinMaxVal.first  = fHist->GetBinContent(fCoord->GetFirstXBin(), fCoord->GetFirstYBin());

   fMinMaxVal.second = fMinMaxVal.first;


   for (Int_t i = fCoord->GetFirstXBin(), e = fCoord->GetLastXBin(); i <= e; ++i) {

      for (Int_t j = fCoord->GetFirstYBin(), e1 = fCoord->GetLastYBin(); j <= e1; ++j) {

         Double_t val = fHist->GetBinContent(i, j);

         fMinMaxVal.first  = TMath::Min(fMinMaxVal.first, val);

         fMinMaxVal.second = TMath::Max(fMinMaxVal.second, val);

      }

   }


   return kTRUE;

}


////////////////////////////////////////////////////////////////////////////////

///Geometry for lego in spherical coords.


Bool_t TGLLegoPainter::InitGeometrySpherical()

{

   if (!fCoord->SetRanges(fHist, kFALSE, kFALSE))

      return kFALSE;


   fBackBox.SetPlotBox(fCoord->GetXRangeScaled(), fCoord->GetYRangeScaled(), fCoord->GetZRangeScaled());


   const Int_t nY = fCoord->GetNYBins();

   fCosSinTableY.resize(nY + 1);

   const Double_t fullTheta = fYAxis->GetXmax() - fYAxis->GetXmin();

   const Double_t thetaLow  = fYAxis->GetXmin();

   Double_t angle = 0.;

   for (Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {

      angle = (fYAxis->GetBinLowEdge(jr) - thetaLow) / fullTheta * TMath::Pi();

      fCosSinTableY[j].first = TMath::Cos(angle);

      fCosSinTableY[j].second = TMath::Sin(angle);

   }

   angle = (fYAxis->GetBinUpEdge(fCoord->GetLastYBin()) - thetaLow) / fullTheta * TMath::Pi();

   fCosSinTableY[nY].first = TMath::Cos(angle);

   fCosSinTableY[nY].second = TMath::Sin(angle);


   const Int_t nX = fCoord->GetNXBins();

   fCosSinTableX.resize(nX + 1);

   const Double_t fullPhi = fXAxis->GetXmax() - fXAxis->GetXmin();

   const Double_t phiLow  = fXAxis->GetXmin();


   for (Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {

      angle = (fXAxis->GetBinLowEdge(ir) - phiLow) / fullPhi * TMath::TwoPi();

      fCosSinTableX[i].first  = TMath::Cos(angle);

      fCosSinTableX[i].second = TMath::Sin(angle);

   }


   angle = (fXAxis->GetBinUpEdge(fCoord->GetLastXBin()) - phiLow) / fullPhi * TMath::TwoPi();

   fCosSinTableX[nX].first  = TMath::Cos(angle);

   fCosSinTableX[nX].second = TMath::Sin(angle);


   fMinZ = fCoord->GetZRange().first;

   if (fMinZ < 0.)

      fCoord->GetZRange().second > 0. ? fMinZ = 0. : fMinZ = fCoord->GetZRange().second;


   fMinMaxVal.first  = fHist->GetBinContent(fCoord->GetFirstXBin(), fCoord->GetFirstYBin());

   fMinMaxVal.second = fMinMaxVal.first;


   for (Int_t i = fCoord->GetFirstXBin(), e = fCoord->GetLastXBin(); i <= e; ++i) {

      for (Int_t j = fCoord->GetFirstYBin(), e1 = fCoord->GetLastYBin(); j <= e1; ++j) {

         Double_t val = fHist->GetBinContent(i, j);

         fMinMaxVal.first  = TMath::Min(fMinMaxVal.first, val);

         fMinMaxVal.second = TMath::Max(fMinMaxVal.second, val);

      }

   }


   return kTRUE;

}


////////////////////////////////////////////////////////////////////////////////

///User clicks on a lego with middle mouse button (middle for pad).


void TGLLegoPainter::StartPan(Int_t px, Int_t py)

{

   fMousePosition.fX = px;

   fMousePosition.fY = fCamera->GetHeight() - py;

   fCamera->StartPan(px, py);

   fBoxCut.StartMovement(px, py);

}


////////////////////////////////////////////////////////////////////////////////

///Move lego or section.


void TGLLegoPainter::Pan(Int_t px, Int_t py)

{

   if (fSelectedPart >= fSelectionBase || fSelectedPart == 1) {

      SaveModelviewMatrix();

      SaveProjectionMatrix();


      fCamera->SetCamera();

      fCamera->Apply(fPadPhi, fPadTheta);

      fCamera->Pan(px, py);


      RestoreProjectionMatrix();

      RestoreModelviewMatrix();

   } else if (fSelectedPart > 0) {

      //Convert py into bottom-top orientation.

      py = fCamera->GetHeight() - py;


      SaveModelviewMatrix();

      SaveProjectionMatrix();


      fCamera->SetCamera();

      fCamera->Apply(fPadPhi, fPadTheta);


      if (!fHighColor) {

         if (fBoxCut.IsActive() && (fSelectedPart >= kXAxis && fSelectedPart <= kZAxis))

            fBoxCut.MoveBox(px, py, fSelectedPart);

         else

            MoveSection(px, py);

      } else

         MoveSection(px, py);


      RestoreProjectionMatrix();

      RestoreModelviewMatrix();

   }


   fMousePosition.fX = px, fMousePosition.fY = py;

   fUpdateSelection = kTRUE;

}


////////////////////////////////////////////////////////////////////////////////

///Parse additional options.


void TGLLegoPainter::AddOption(const TString &option)

{

   using namespace std;

   const Ssiz_t legoPos = option.Index("lego");//"lego" _already_ _exists_ in a string.

   if (legoPos + 4 < option.Length() && isdigit(option[legoPos + 4])) {

      switch (option[legoPos + 4] - '0') {

      case 1:

         fLegoType = kColorSimple;

         break;

      case 2:

         fLegoType = kColorLevel;

         break;

      case 3:

         fLegoType = kCylindricBars;

         break;

      default:

         fLegoType = kColorSimple;

         break;

      }

   } else

      fLegoType = kColorSimple;

   //check 'e' option

   Ssiz_t ePos = option.Index("e");

   if (ePos == legoPos + 1)

      ePos = option.Index("e", legoPos + 4);

   fDrawErrors = ePos != kNPOS ? kTRUE : kFALSE;


   option.Index("z") == kNPOS ? fDrawPalette = kFALSE : fDrawPalette = kTRUE;

}


////////////////////////////////////////////////////////////////////////////////

///Initialize some gl state variables.


void TGLLegoPainter::InitGL()const

{

   glEnable(GL_DEPTH_TEST);

   glEnable(GL_LIGHTING);

   glEnable(GL_LIGHT0);

   //For lego, back polygons are culled (but not for sections).

   glEnable(GL_CULL_FACE);

   glCullFace(GL_BACK);


   glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);

}


////////////////////////////////////////////////////////////////////////////////

///Return some gl states to original values.


void TGLLegoPainter::DeInitGL()const

{

   glDisable(GL_DEPTH_TEST);

   glDisable(GL_LIGHTING);

   glDisable(GL_LIGHT0);

   glDisable(GL_CULL_FACE);

   glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);

}


////////////////////////////////////////////////////////////////////////////////

///Select method corresponding to coordinate system.


void TGLLegoPainter::DrawPlot()const

{

   //Shift plot to point of origin.

   const Rgl::PlotTranslation trGuard(this);


   switch (fCoord->GetCoordType()) {

   case kGLCartesian:

      return DrawLegoCartesian();

   case kGLPolar:

      return DrawLegoPolar();

   case kGLCylindrical:

      return DrawLegoCylindrical();

   case kGLSpherical:

      return DrawLegoSpherical();

   default:;

   }

}


////////////////////////////////////////////////////////////////////////////////

///Lego in cartesian system.


void TGLLegoPainter::DrawLegoCartesian()const

{

   if (fCoord->GetCoordType() == kGLCartesian) {

      fBackBox.DrawBox(fSelectedPart, fSelectionPass, fZLevels, fHighColor);

      const TGLDisableGuard cullGuard(GL_CULL_FACE);

      DrawSections();

   }


   //const TGLDisableGuard depthTest(GL_DEPTH_TEST); //[0-0]


   if (!fSelectionPass) {

      glEnable(GL_POLYGON_OFFSET_FILL);//[0

      glPolygonOffset(1.f, 1.f);

      SetLegoColor();

      if (fXOZSectionPos > fBackBox.Get3DBox()[0].Y() || fYOZSectionPos> fBackBox.Get3DBox()[0].X()) {

         //Lego is semi-transparent if we have any sections.

         glEnable(GL_BLEND);//[1

         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

      }

   }


   //Using front point, find the correct order to draw bars from

   //back to front (it's important only for semi-transparent lego).

   //Only in cartesian.

   const Int_t nX = fXEdges.size();

   const Int_t nY = fYEdges.size();

   const Int_t frontPoint = fBackBox.GetFrontPoint();

   Int_t iInit = 0, jInit = 0, irInit = fCoord->GetFirstXBin(), jrInit = fCoord->GetFirstYBin();

   const Int_t addI = frontPoint == 2 || frontPoint == 1 ? 1 : (iInit = nX - 1, irInit = fCoord->GetLastXBin(), -1);

   const Int_t addJ = frontPoint == 2 || frontPoint == 3 ? 1 : (jInit = nY - 1, jrInit = fCoord->GetLastYBin(), -1);


   if (fLegoType == kColorLevel && !fSelectionPass) {

      if (!PreparePalette()) {

         fLegoType = kColorSimple;

         fDrawPalette = kFALSE;

      } else

         fPalette.EnableTexture(GL_MODULATE);

   }


   if (fSelectionPass && fHighColor)

      Rgl::ObjectIDToColor(fSelectionBase, kTRUE);


   for(Int_t i = iInit, ir = irInit; addI > 0 ? i < nX : i >= 0; i += addI, ir += addI) {

      for(Int_t j = jInit, jr = jrInit; addJ > 0 ? j < nY : j >= 0; j += addJ, jr += addJ) {

         Double_t zMax = fHist->GetBinContent(ir, jr) * fCoord->GetFactor();

         if (!ClampZ(zMax))

            continue;


         const Int_t binID = fSelectionBase + i * fCoord->GetNYBins() + j;


         if (fSelectionPass && !fHighColor)

            Rgl::ObjectIDToColor(binID, kFALSE);

         else if(!fHighColor && fSelectedPart == binID)

            glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gOrangeEmission);


         if (fLegoType == kCylindricBars) {

            Rgl::DrawCylinder(&fQuadric, fXEdges[i].first, fXEdges[i].second, fYEdges[j].first,

                              fYEdges[j].second, fMinZ, zMax);

         } else if (fLegoType == kColorLevel && !fSelectionPass) {

            Rgl::DrawBoxFrontTextured(fXEdges[i].first, fXEdges[i].second, fYEdges[j].first,

                                      fYEdges[j].second, fMinZ, zMax, fPalette.GetTexCoord(fMinZ),

                                      fPalette.GetTexCoord(zMax), frontPoint);

         } else {

            Rgl::DrawBoxFront(fXEdges[i].first, fXEdges[i].second, fYEdges[j].first,

                              fYEdges[j].second, fMinZ, zMax, frontPoint);

         }


         if (!fHighColor && !fSelectionPass && fSelectedPart == binID)

            glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gNullEmission);

      }

   }


   if (fLegoType == kColorLevel && !fSelectionPass)

      fPalette.DisableTexture();


   //Draw outlines for non-cylindrical bars.

   if (!fSelectionPass) {

      glDisable(GL_POLYGON_OFFSET_FILL);//0]

      const TGLDisableGuard lightGuard(GL_LIGHTING);//[2 - 2]

      if (fXOZSectionPos <= fBackBox.Get3DBox()[0].Y() && fYOZSectionPos <= fBackBox.Get3DBox()[0].X())

         glColor3d(0., 0., 0.);

      else

         glColor4d(0., 0., 0., 0.4);

      glPolygonMode(GL_FRONT, GL_LINE);//[3


      const TGLEnableGuard blendGuard(GL_BLEND);//[4-4] + 1]

      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

      const TGLEnableGuard smoothGuard(GL_LINE_SMOOTH);//[5-5]

      glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);


      for(Int_t i = iInit, ir = irInit; addI > 0 ? i < nX : i >= 0; i += addI, ir += addI) {

         for(Int_t j = jInit, jr = jrInit; addJ > 0 ? j < nY : j >= 0; j += addJ, jr += addJ) {

            Double_t zMax = fHist->GetBinContent(ir, jr) * fCoord->GetFactor();

            if (!ClampZ(zMax))

               continue;

            if (fLegoType != kCylindricBars) {

               Rgl::DrawBoxFront(fXEdges[i].first, fXEdges[i].second, fYEdges[j].first,

                                 fYEdges[j].second, fMinZ, zMax, frontPoint);

            }

            if (fDrawErrors && zMax > 0.) {

               Double_t errorZMax = (fHist->GetBinContent(ir, jr) + fHist->GetBinError(ir, jr)) * fCoord->GetFactor();

               ClampZ(errorZMax);

               Rgl::DrawError(fXEdges[i].first, fXEdges[i].second, fYEdges[j].first,

                              fYEdges[j].second, zMax, errorZMax);

            }

         }

      }


      glPolygonMode(GL_FRONT, GL_FILL);//3]

   }


   if(!fSelectionPass && fDrawPalette)

      DrawPalette();

}


////////////////////////////////////////////////////////////////////////////////

///Lego in polar system.


void TGLLegoPainter::DrawLegoPolar()const

{

   const Int_t nX = fCosSinTableX.size() - 1;

   const Int_t nY = fYEdges.size();


   if (!fSelectionPass) {

      SetLegoColor();

      glEnable(GL_POLYGON_OFFSET_FILL);

      glPolygonOffset(1.f, 1.f);

   }


   Double_t points[4][2] = {};


   if (fLegoType == kColorLevel && !fSelectionPass) {

      if (!PreparePalette()) {

         fLegoType = kColorSimple;

         fDrawPalette = kFALSE;

      } else

         fPalette.EnableTexture(GL_MODULATE);

   }


   if (fHighColor && fSelectionPass)

      Rgl::ObjectIDToColor(fSelectionBase, kTRUE);


   for(Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {

      for(Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {

         Double_t zMax = fHist->GetBinContent(ir, jr);

         if (!ClampZ(zMax))

            continue;

         points[0][0] = fYEdges[j].first  * fCosSinTableX[i].first;

         points[0][1] = fYEdges[j].first  * fCosSinTableX[i].second;

         points[1][0] = fYEdges[j].second * fCosSinTableX[i].first;

         points[1][1] = fYEdges[j].second * fCosSinTableX[i].second;

         points[2][0] = fYEdges[j].second * fCosSinTableX[i + 1].first;

         points[2][1] = fYEdges[j].second * fCosSinTableX[i + 1].second;

         points[3][0] = fYEdges[j].first  * fCosSinTableX[i + 1].first;

         points[3][1] = fYEdges[j].first  * fCosSinTableX[i + 1].second;


         const Int_t binID = fSelectionBase + i * fCoord->GetNYBins() + j;


         if (!fHighColor && fSelectionPass)

            Rgl::ObjectIDToColor(binID, kFALSE);

         else if(!fHighColor && fSelectedPart == binID)

            glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gOrangeEmission);


         if (fLegoType == kColorLevel && !fSelectionPass)

            Rgl::DrawTrapezoidTextured(points, fMinZ, zMax, fPalette.GetTexCoord(fMinZ),

                                       fPalette.GetTexCoord(zMax));

         else

            Rgl::DrawTrapezoid(points, fMinZ, zMax);


         if (!fHighColor && !fSelectionPass && fSelectedPart == binID)

            glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gNullEmission);

      }

   }


   if (fLegoType == kColorLevel && !fSelectionPass)

      fPalette.DisableTexture();


   //Draw outlines.

   if (!fSelectionPass) {

      glDisable(GL_POLYGON_OFFSET_FILL);//0]

      const TGLDisableGuard lightGuard(GL_LIGHTING);//[2-2]

      glColor3d(0., 0., 0.);

      glPolygonMode(GL_FRONT, GL_LINE);//[3

      const TGLEnableGuard blendGuard(GL_BLEND);

      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

      const TGLEnableGuard smoothGuard(GL_LINE_SMOOTH);

      glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);


      for(Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {

         for(Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {

            Double_t zMax = fHist->GetBinContent(ir, jr);

            if (!ClampZ(zMax))

               continue;

            points[0][0] = fYEdges[j].first  * fCosSinTableX[i].first;

            points[0][1] = fYEdges[j].first  * fCosSinTableX[i].second;

            points[1][0] = fYEdges[j].second * fCosSinTableX[i].first;

            points[1][1] = fYEdges[j].second * fCosSinTableX[i].second;

            points[2][0] = fYEdges[j].second * fCosSinTableX[i + 1].first;

            points[2][1] = fYEdges[j].second * fCosSinTableX[i + 1].second;

            points[3][0] = fYEdges[j].first  * fCosSinTableX[i + 1].first;

            points[3][1] = fYEdges[j].first  * fCosSinTableX[i + 1].second;

            Rgl::DrawTrapezoid(points, fMinZ, zMax, kFALSE);

         }

      }


      glPolygonMode(GL_FRONT, GL_FILL);//3]

   }


   if(!fSelectionPass && fDrawPalette)

      DrawPalette();

}


////////////////////////////////////////////////////////////////////////////////

///Lego in cylindrical system.


void TGLLegoPainter::DrawLegoCylindrical()const

{

   const Int_t nX = fCosSinTableX.size() - 1;

   const Int_t nY = fYEdges.size();

   Double_t legoR = gStyle->GetLegoInnerR();

   if (legoR > 1. || legoR < 0.)

      legoR = 0.5;

   const Double_t rRange = fCoord->GetZLength();


   if (!fSelectionPass) {

      SetLegoColor();

      glEnable(GL_POLYGON_OFFSET_FILL);

      glPolygonOffset(1.f, 1.f);

   }


   Double_t points[4][2] = {};

   const Double_t sc = (1 - legoR) * fCoord->GetXScale();

   legoR *= fCoord->GetXScale();


   if (fLegoType == kColorLevel && !fSelectionPass) {

      if (!PreparePalette()) {

         fLegoType = kColorSimple;

         fDrawPalette = kFALSE;

      } else

         fPalette.EnableTexture(GL_MODULATE);

   }


   if (fHighColor && fSelectionPass)

      Rgl::ObjectIDToColor(fSelectionBase, kTRUE);


   for(Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {

      for(Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {

         Double_t zMin = legoR + (fMinZ - fCoord->GetZRange().first) / rRange * sc;

         Double_t zMax = legoR + (fHist->GetBinContent(ir, jr) - fCoord->GetZRange().first) / rRange * sc;

         if (zMin > zMax)

            std::swap(zMin, zMax);


         points[0][0] = fCosSinTableX[i].first * zMin;

         points[0][1] = fCosSinTableX[i].second * zMin;

         points[1][0] = fCosSinTableX[i].first * zMax;

         points[1][1] = fCosSinTableX[i].second * zMax;

         points[2][0] = fCosSinTableX[i + 1].first * zMax;

         points[2][1] = fCosSinTableX[i + 1].second * zMax;

         points[3][0] = fCosSinTableX[i + 1].first * zMin;

         points[3][1] = fCosSinTableX[i + 1].second * zMin;


         const Int_t binID = fSelectionBase + i * fCoord->GetNYBins() + j;


         if (fSelectionPass && !fHighColor)

            Rgl::ObjectIDToColor(binID, kFALSE);

         else if(!fHighColor && fSelectedPart == binID)

            glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gOrangeEmission);


         if (fLegoType == kColorLevel && !fSelectionPass){

            Rgl::DrawTrapezoidTextured2(points, fYEdges[j].first, fYEdges[j].second,

                                        fPalette.GetTexCoord(fMinZ), fPalette.GetTexCoord(fHist->GetBinContent(ir, jr)));

         }else

            Rgl::DrawTrapezoid(points, fYEdges[j].first, fYEdges[j].second);


         if(!fSelectionPass && !fHighColor && fSelectedPart == binID)

            glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gNullEmission);

      }

   }


   if (fLegoType == kColorLevel && !fSelectionPass)

      fPalette.DisableTexture();


   //Draw outlines.

   if (!fSelectionPass) {

      glDisable(GL_POLYGON_OFFSET_FILL);//0]

      const TGLDisableGuard lightGuard(GL_LIGHTING);//[2-2]

      glColor3d(0., 0., 0.);

      glPolygonMode(GL_FRONT, GL_LINE);//[3


      const TGLEnableGuard blendGuard(GL_BLEND);

      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

      const TGLEnableGuard smoothGuard(GL_LINE_SMOOTH);

      glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);


      for(Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {

         for(Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {

            Double_t zMin = legoR + (fMinZ - fCoord->GetZRange().first) / rRange * sc;

            Double_t zMax = legoR + (fHist->GetBinContent(ir, jr) - fCoord->GetZRange().first) / rRange * sc;

            if (zMin > zMax)

               std::swap(zMin, zMax);


            points[0][0] = fCosSinTableX[i].first * zMin;

            points[0][1] = fCosSinTableX[i].second * zMin;

            points[1][0] = fCosSinTableX[i].first * zMax;

            points[1][1] = fCosSinTableX[i].second * zMax;

            points[2][0] = fCosSinTableX[i + 1].first * zMax;

            points[2][1] = fCosSinTableX[i + 1].second * zMax;

            points[3][0] = fCosSinTableX[i + 1].first * zMin;

            points[3][1] = fCosSinTableX[i + 1].second * zMin;

            Rgl::DrawTrapezoid(points, fYEdges[j].first, fYEdges[j].second);

         }

      }


      glPolygonMode(GL_FRONT, GL_FILL);//3]

   }


   if(!fSelectionPass && fDrawPalette)

      DrawPalette();

}


////////////////////////////////////////////////////////////////////////////////

///Lego in spherical system.


void TGLLegoPainter::DrawLegoSpherical()const

{

   const Int_t nX = fCosSinTableX.size() - 1;

   const Int_t nY = fCosSinTableY.size() - 1;

   const Double_t rRange = fCoord->GetZLength();

   Double_t legoR = gStyle->GetLegoInnerR();

   if (legoR > 1. || legoR < 0.)

      legoR = 0.5;


   if (!fSelectionPass) {

      SetLegoColor();

      glEnable(GL_POLYGON_OFFSET_FILL);

      glPolygonOffset(1.f, 1.f);

   }


   Double_t points[8][3] = {};

   const Double_t sc = 1 - legoR;


   if (fLegoType == kColorLevel && !fSelectionPass) {

      if (!PreparePalette()) {

         fLegoType = kColorSimple;

         fDrawPalette = kFALSE;

      } else

         fPalette.EnableTexture(GL_MODULATE);

   }


   if (fSelectionPass && fHighColor)

      Rgl::ObjectIDToColor(fSelectionBase, kTRUE);


   for(Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {

      for(Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {

         Double_t zMin = legoR + (fMinZ - fCoord->GetZRange().first) / rRange * sc;

         Double_t zMax = legoR + (fHist->GetBinContent(ir, jr) - fCoord->GetZRange().first) / rRange * sc;

         if (zMin > zMax)

            std::swap(zMin, zMax);


         points[4][0] = zMin * fCosSinTableY[j].second * fCosSinTableX[i].first;

         points[4][1] = zMin * fCosSinTableY[j].second * fCosSinTableX[i].second;

         points[4][2] = zMin * fCosSinTableY[j].first;

         points[5][0] = zMin * fCosSinTableY[j].second * fCosSinTableX[i + 1].first;

         points[5][1] = zMin * fCosSinTableY[j].second * fCosSinTableX[i + 1].second;

         points[5][2] = zMin * fCosSinTableY[j].first;

         points[6][0] = zMax * fCosSinTableY[j].second * fCosSinTableX[i + 1].first;

         points[6][1] = zMax * fCosSinTableY[j].second * fCosSinTableX[i + 1].second;

         points[6][2] = zMax * fCosSinTableY[j].first;

         points[7][0] = zMax * fCosSinTableY[j].second * fCosSinTableX[i].first;

         points[7][1] = zMax * fCosSinTableY[j].second * fCosSinTableX[i].second;

         points[7][2] = zMax * fCosSinTableY[j].first;

         points[0][0] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i].first;

         points[0][1] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i].second;

         points[0][2] = zMin * fCosSinTableY[j + 1].first;

         points[1][0] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].first;

         points[1][1] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].second;

         points[1][2] = zMin * fCosSinTableY[j + 1].first;

         points[2][0] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].first;

         points[2][1] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].second;

         points[2][2] = zMax * fCosSinTableY[j + 1].first;

         points[3][0] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i].first;

         points[3][1] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i].second;

         points[3][2] = zMax * fCosSinTableY[j + 1].first;


         const Int_t binID = fSelectionBase + i * fCoord->GetNYBins() + j;


         if (fSelectionPass && !fHighColor)

            Rgl::ObjectIDToColor(binID, kFALSE);

         else if(!fHighColor && fSelectedPart == binID)

            glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gOrangeEmission);

         if (fLegoType == kColorLevel && !fSelectionPass)

            Rgl::DrawTrapezoidTextured(points, fPalette.GetTexCoord(fMinZ),

                                       fPalette.GetTexCoord(fHist->GetBinContent(ir, jr)));

         else

            Rgl::DrawTrapezoid(points);


         if(!fHighColor && fSelectedPart == binID)

            glMaterialfv(GL_FRONT, GL_EMISSION, Rgl::gNullEmission);

      }

   }


   if (fLegoType == kColorLevel && !fSelectionPass)

      fPalette.DisableTexture();


   //Draw outlines.

   if (!fSelectionPass) {

      glDisable(GL_POLYGON_OFFSET_FILL);//0]

      const TGLDisableGuard lightGuard(GL_LIGHTING);//[2-2]

      glColor3d(0., 0., 0.);

      glPolygonMode(GL_FRONT, GL_LINE);//[3

      const TGLEnableGuard blendGuard(GL_BLEND);

      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

      const TGLEnableGuard smoothGuard(GL_LINE_SMOOTH);

      glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);


      for(Int_t i = 0, ir = fCoord->GetFirstXBin(); i < nX; ++i, ++ir) {

         for(Int_t j = 0, jr = fCoord->GetFirstYBin(); j < nY; ++j, ++jr) {

            Double_t zMin = legoR + (fMinZ - fCoord->GetZRange().first) / rRange * sc;

            Double_t zMax = legoR + (fHist->GetBinContent(ir, jr) - fCoord->GetZRange().first) / rRange * sc;

            if (zMin > zMax)

               std::swap(zMin, zMax);


            points[4][0] = zMin * fCosSinTableY[j].second * fCosSinTableX[i].first;

            points[4][1] = zMin * fCosSinTableY[j].second * fCosSinTableX[i].second;

            points[4][2] = zMin * fCosSinTableY[j].first;

            points[5][0] = zMin * fCosSinTableY[j].second * fCosSinTableX[i + 1].first;

            points[5][1] = zMin * fCosSinTableY[j].second * fCosSinTableX[i + 1].second;

            points[5][2] = zMin * fCosSinTableY[j].first;

            points[6][0] = zMax * fCosSinTableY[j].second * fCosSinTableX[i + 1].first;

            points[6][1] = zMax * fCosSinTableY[j].second * fCosSinTableX[i + 1].second;

            points[6][2] = zMax * fCosSinTableY[j].first;

            points[7][0] = zMax * fCosSinTableY[j].second * fCosSinTableX[i].first;

            points[7][1] = zMax * fCosSinTableY[j].second * fCosSinTableX[i].second;

            points[7][2] = zMax * fCosSinTableY[j].first;

            points[0][0] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i].first;

            points[0][1] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i].second;

            points[0][2] = zMin * fCosSinTableY[j + 1].first;

            points[1][0] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].first;

            points[1][1] = zMin * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].second;

            points[1][2] = zMin * fCosSinTableY[j + 1].first;

            points[2][0] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].first;

            points[2][1] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i + 1].second;

            points[2][2] = zMax * fCosSinTableY[j + 1].first;

            points[3][0] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i].first;

            points[3][1] = zMax * fCosSinTableY[j + 1].second * fCosSinTableX[i].second;

            points[3][2] = zMax * fCosSinTableY[j + 1].first;

            Rgl::DrawTrapezoid(points);

         }

      }


      glPolygonMode(GL_FRONT, GL_FILL);//3]

   }


   if(!fSelectionPass && fDrawPalette)

      DrawPalette();

}


////////////////////////////////////////////////////////////////////////////////

///Set lego's color.


void TGLLegoPainter::SetLegoColor()const

{

   Float_t diffColor[] = {0.8f, 0.8f, 0.8f, 0.15f};


   if (fLegoType != kColorLevel && fHist->GetFillColor() != kWhite)

      if (const TColor *c = gROOT->GetColor(fHist->GetFillColor()))

         c->GetRGB(diffColor[0], diffColor[1], diffColor[2]);


   glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffColor);

   const Float_t specColor[] = {1.f, 1.f, 1.f, 1.f};

   glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specColor);

   glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 70.f);

}


////////////////////////////////////////////////////////////////////////////////

///XOZ plane parallel section.


void TGLLegoPainter::DrawSectionXOZ()const

{

   Int_t binY = -1;


   for (Int_t i = 0, e = fYEdges.size(); i < e; ++i) {

      if (fYEdges[i].first <= fXOZSectionPos && fXOZSectionPos <= fYEdges[i].second) {

         binY = i;

         break;

      }

   }


   if (binY >= 0) {

      binY += fCoord->GetFirstYBin();

      glColor3d(1., 0., 0.);

      glLineWidth(3.f);

      //Draw 2d hist on the profile's plane.

      for (UInt_t i = 0, ir = fCoord->GetFirstXBin(), e = fXEdges.size(); i < e; ++i, ++ir) {

         Double_t zMax = fHist->GetBinContent(Int_t(ir), binY);

         if (!ClampZ(zMax))

            continue;


         glBegin(GL_LINE_LOOP);

         glVertex3d(fXEdges[i].first,  fXOZSectionPos, fMinZ);

         glVertex3d(fXEdges[i].first,  fXOZSectionPos, zMax);

         glVertex3d(fXEdges[i].second, fXOZSectionPos, zMax);

         glVertex3d(fXEdges[i].second, fXOZSectionPos, fMinZ);

         glEnd();

      }


      glLineWidth(1.f);

   }

}


////////////////////////////////////////////////////////////////////////////////

///YOZ plane parallel section.


void TGLLegoPainter::DrawSectionYOZ()const

{

   Int_t binX = -1;


   for (Int_t i = 0, e = fXEdges.size(); i < e; ++i) {

      if (fXEdges[i].first <= fYOZSectionPos && fYOZSectionPos <= fXEdges[i].second) {

         binX = i;

         break;

      }

   }


   if (binX >= 0) {

      binX += fCoord->GetFirstXBin();//fBinsX.first;

      glColor3d(1., 0., 0.);

      glLineWidth(3.f);

      //Draw 2d hist on the profile's plane.

      for (UInt_t i = 0, ir = fCoord->GetFirstYBin(), e = fYEdges.size(); i < e; ++i, ++ir) {

         Double_t zMax = fHist->GetBinContent(binX, ir);

         if (!ClampZ(zMax))

            continue;


         glBegin(GL_LINE_LOOP);

         glVertex3d(fYOZSectionPos, fYEdges[i].first,  fMinZ);

         glVertex3d(fYOZSectionPos, fYEdges[i].first,   zMax);

         glVertex3d(fYOZSectionPos, fYEdges[i].second,  zMax);

         glVertex3d(fYOZSectionPos, fYEdges[i].second, fMinZ);

         glEnd();

      }


      glLineWidth(1.f);

   }

}


////////////////////////////////////////////////////////////////////////////////

///Empty. No such sections for lego.


void TGLLegoPainter::DrawSectionXOY()const

{

}


////////////////////////////////////////////////////////////////////////////////

///Remove all sections and repaint.


void TGLLegoPainter::ProcessEvent(Int_t event, Int_t /*px*/, Int_t py)

{

   const TGLVertex3 *frame = fBackBox.Get3DBox();

   if (event == kButton1Double && (fXOZSectionPos > frame[0].Y() || fYOZSectionPos > frame[0].X())) {

      fXOZSectionPos = frame[0].Y();

      fYOZSectionPos = frame[0].X();

      if (fBoxCut.IsActive())

         fBoxCut.TurnOnOff();

      //gGLManager->PaintSingleObject(this);

      if (!gVirtualX->IsCmdThread())

         gROOT->ProcessLineFast(Form("((TGLPlotPainter *)0x%lx)->Paint()", (ULong_t)this));

      else

         Paint();

   } else if (event == kKeyPress && (py == kKey_c || py == kKey_C)) {

      Info("ProcessEvent", "Box cut does not exist for lego");

   }

}


////////////////////////////////////////////////////////////////////////////////

///Clamp z value.


Bool_t TGLLegoPainter::ClampZ(Double_t &zVal)const

{

   if (fCoord->GetZLog())

      if (zVal <= 0.)

         return kFALSE;

      else

         zVal = TMath::Log10(zVal) * fCoord->GetZScale();

   else

      zVal *= fCoord->GetZScale();


   const TGLVertex3 *frame = fBackBox.Get3DBox();


   if (zVal > frame[4].Z())

      zVal = frame[4].Z();

   else if (zVal < frame[0].Z())

      zVal = frame[0].Z();


   return kTRUE;

}


////////////////////////////////////////////////////////////////////////////////

///Initialize color palette.


Bool_t TGLLegoPainter::PreparePalette()const

{

   if(fMinMaxVal.first == fMinMaxVal.second)

      return kFALSE;//must be std::abs(fMinMaxVal.second - fMinMaxVal.first) < ...


   //User-defined contours are disabled, to be fixed in a future.

   if (fHist->TestBit(TH1::kUserContour))

      fHist->ResetBit(TH1::kUserContour);


   UInt_t paletteSize = gStyle->GetNumberContours();

   if (!paletteSize)

      paletteSize = 20;


   return fPalette.GeneratePalette(paletteSize, Rgl::Range_t(fMinZ, fMinMaxVal.second));

}


////////////////////////////////////////////////////////////////////////////////

///Draw. Palette.

///Originally, fCamera was never null.

///It can be a null now because of gl-viewer.


void TGLLegoPainter::DrawPalette()const

{

   if (!fCamera) {

      //Thank you, gl-viewer!

      return;

   }


   Rgl::DrawPalette(fCamera, fPalette);


   glFinish();


   fCamera->SetCamera();

   fCamera->Apply(fPadPhi, fPadTheta);

}


////////////////////////////////////////////////////////////////////////////////

///Draw. Palette. Axis.


void TGLLegoPainter::DrawPaletteAxis()const

{

   gVirtualX->SetDrawMode(TVirtualX::kCopy);//TCanvas by default sets in kInverse

   Rgl::DrawPaletteAxis(fCamera, fMinMaxVal, fCoord->GetCoordType() == kGLCartesian ? fCoord->GetZLog() : kFALSE);

}

Buttons.h

kKeyPress
@ kKeyPress
Definition: Buttons.h:20

kButton1Double
@ kButton1Double
Definition: Buttons.h:24

KeySymbols.h

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

kNPOS
const Ssiz_t kNPOS
Definition: RtypesCore.h:111

Int_t
int Int_t
Definition: RtypesCore.h:41

Ssiz_t
int Ssiz_t
Definition: RtypesCore.h:63

Char_t
char Char_t
Definition: RtypesCore.h:29

UInt_t
unsigned int UInt_t
Definition: RtypesCore.h:42

kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:88

ULong_t
unsigned long ULong_t
Definition: RtypesCore.h:51

Bool_t
bool Bool_t
Definition: RtypesCore.h:59

Double_t
double Double_t
Definition: RtypesCore.h:55

Float_t
float Float_t
Definition: RtypesCore.h:53

kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:87

ClassImp
#define ClassImp(name)
Definition: Rtypes.h:363

kWhite
@ kWhite
Definition: Rtypes.h:62

TAxis.h

TClass.h

TColor.h

Info
void Info(const char *location, const char *msgfmt,...)

TGLIncludes.h

TGLLegoPainter.h

TGLPlotCamera.h

kGLSpherical
@ kGLSpherical
Definition: TGLUtil.h:46

kGLCylindrical
@ kGLCylindrical
Definition: TGLUtil.h:45

kGLPolar
@ kGLPolar
Definition: TGLUtil.h:44

kGLCartesian
@ kGLCartesian
Definition: TGLUtil.h:43

TH1.h

TMath.h

TROOT.h

gROOT
#define gROOT
Definition: TROOT.h:410

TString.h

Form
char * Form(const char *fmt,...)

TStyle.h

gStyle
R__EXTERN TStyle * gStyle
Definition: TStyle.h:406

TVirtualX.h

gVirtualX
#define gVirtualX
Definition: TVirtualX.h:345

points
point * points
Definition: X3DBuffer.c:22

Rgl::PlotTranslation
Definition: TGLPlotPainter.h:170

TAttFill::GetFillColor
virtual Color_t GetFillColor() const
Return the fill area color.
Definition: TAttFill.h:30

TAxis::GetXmax
Double_t GetXmax() const
Definition: TAxis.h:134

TAxis::GetBinLowEdge
virtual Double_t GetBinLowEdge(Int_t bin) const
Return low edge of bin.
Definition: TAxis.cxx:504

TAxis::GetXmin
Double_t GetXmin() const
Definition: TAxis.h:133

TAxis::GetBinWidth
virtual Double_t GetBinWidth(Int_t bin) const
Return bin width.
Definition: TAxis.cxx:526

TAxis::GetBinUpEdge
virtual Double_t GetBinUpEdge(Int_t bin) const
Return up edge of bin.
Definition: TAxis.cxx:514

TColor
The color creation and management class.
Definition: TColor.h:19

TGLBoxCut::MoveBox
void MoveBox(Int_t px, Int_t py, Int_t axisID)
Move box cut along selected direction.
Definition: TGLPlotPainter.cxx:1590

TGLBoxCut::TurnOnOff
void TurnOnOff()
Turn the box cut on/off.
Definition: TGLPlotPainter.cxx:1453

TGLBoxCut::StartMovement
void StartMovement(Int_t px, Int_t py)
Start cut's movement.
Definition: TGLPlotPainter.cxx:1581

TGLBoxCut::IsActive
Bool_t IsActive() const
Definition: TGLPlotPainter.h:59

TGLDisableGuard
Definition: TGLUtil.h:1118

TGLEnableGuard
Definition: TGLUtil.h:1105

TGLLegoPainter
Plot-painter implementing LEGO rendering of TH2 histograms in cartesian, polar, cylindrical and spher...
Definition: TGLLegoPainter.h:28

TGLLegoPainter::InitGeometryCartesian
Bool_t InitGeometryCartesian()
Geometry for lego in cartesian coords.
Definition: TGLLegoPainter.cxx:99

TGLLegoPainter::PreparePalette
Bool_t PreparePalette() const
Initialize color palette.
Definition: TGLLegoPainter.cxx:1116

TGLLegoPainter::DrawLegoSpherical
void DrawLegoSpherical() const
Lego in spherical system.
Definition: TGLLegoPainter.cxx:839

TGLLegoPainter::fXEdges
std::vector< Rgl::Range_t > fXEdges
Definition: TGLLegoPainter.h:41

TGLLegoPainter::InitGeometryCylindrical
Bool_t InitGeometryCylindrical()
Geometry for lego in cylindrical coords.
Definition: TGLLegoPainter.cxx:262

TGLLegoPainter::fDrawErrors
Bool_t fDrawErrors
Definition: TGLLegoPainter.h:49

TGLLegoPainter::fMinZ
Double_t fMinZ
Definition: TGLLegoPainter.h:38

TGLLegoPainter::ProcessEvent
void ProcessEvent(Int_t event, Int_t px, Int_t py)
Remove all sections and repaint.
Definition: TGLLegoPainter.cxx:1072

TGLLegoPainter::fPalette
TGLLevelPalette fPalette
Definition: TGLLegoPainter.h:51

TGLLegoPainter::DrawLegoPolar
void DrawLegoPolar() const
Lego in polar system.
Definition: TGLLegoPainter.cxx:634

TGLLegoPainter::DrawSectionXOZ
void DrawSectionXOZ() const
XOZ plane parallel section.
Definition: TGLLegoPainter.cxx:993

TGLLegoPainter::ClampZ
Bool_t ClampZ(Double_t &zVal) const
Clamp z value.
Definition: TGLLegoPainter.cxx:1093

TGLLegoPainter::InitGL
void InitGL() const
Initialize some gl state variables.
Definition: TGLLegoPainter.cxx:468

TGLLegoPainter::InitGeometrySpherical
Bool_t InitGeometrySpherical()
Geometry for lego in spherical coords.
Definition: TGLLegoPainter.cxx:325

TGLLegoPainter::fQuadric
TGLQuadric fQuadric
Definition: TGLLegoPainter.h:48

TGLLegoPainter::TGLLegoPainter
TGLLegoPainter(const TGLLegoPainter &)

TGLLegoPainter::DrawPalette
void DrawPalette() const
Draw.
Definition: TGLLegoPainter.cxx:1137

TGLLegoPainter::DrawSectionYOZ
void DrawSectionYOZ() const
YOZ plane parallel section.
Definition: TGLLegoPainter.cxx:1029

TGLLegoPainter::DrawLegoCartesian
void DrawLegoCartesian() const
Lego in cartesian system.
Definition: TGLLegoPainter.cxx:516

TGLLegoPainter::SetLegoColor
void SetLegoColor() const
Set lego's color.
Definition: TGLLegoPainter.cxx:976

TGLLegoPainter::InitGeometry
Bool_t InitGeometry()
Select method.
Definition: TGLLegoPainter.cxx:77

TGLLegoPainter::DrawSectionXOY
void DrawSectionXOY() const
Empty. No such sections for lego.
Definition: TGLLegoPainter.cxx:1065

TGLLegoPainter::StartPan
void StartPan(Int_t px, Int_t py)
User clicks on a lego with middle mouse button (middle for pad).
Definition: TGLLegoPainter.cxx:383

TGLLegoPainter::fYEdges
std::vector< Rgl::Range_t > fYEdges
Definition: TGLLegoPainter.h:42

TGLLegoPainter::DeInitGL
void DeInitGL() const
Return some gl states to original values.
Definition: TGLLegoPainter.cxx:483

TGLLegoPainter::fCosSinTableX
std::vector< CosSin_t > fCosSinTableX
Definition: TGLLegoPainter.h:45

TGLLegoPainter::kColorSimple
@ kColorSimple
Definition: TGLLegoPainter.h:32

TGLLegoPainter::kCylindricBars
@ kCylindricBars
Definition: TGLLegoPainter.h:34

TGLLegoPainter::kColorLevel
@ kColorLevel
Definition: TGLLegoPainter.h:33

TGLLegoPainter::fMinMaxVal
Rgl::Range_t fMinMaxVal
Definition: TGLLegoPainter.h:39

TGLLegoPainter::fBinInfo
TString fBinInfo
Definition: TGLLegoPainter.h:47

TGLLegoPainter::DrawLegoCylindrical
void DrawLegoCylindrical() const
Lego in cylindrical system.
Definition: TGLLegoPainter.cxx:731

TGLLegoPainter::GetPlotInfo
char * GetPlotInfo(Int_t px, Int_t py)
Obtain bin's info (i, j, value).
Definition: TGLLegoPainter.cxx:52

TGLLegoPainter::fCosSinTableY
std::vector< CosSin_t > fCosSinTableY
Definition: TGLLegoPainter.h:46

TGLLegoPainter::DrawPlot
void DrawPlot() const
Select method corresponding to coordinate system.
Definition: TGLLegoPainter.cxx:495

TGLLegoPainter::InitGeometryPolar
Bool_t InitGeometryPolar()
Geometry for lego in polar coords.
Definition: TGLLegoPainter.cxx:202

TGLLegoPainter::fLegoType
ELegoType fLegoType
Definition: TGLLegoPainter.h:37

TGLLegoPainter::AddOption
void AddOption(const TString &stringOption)
Parse additional options.
Definition: TGLLegoPainter.cxx:435

TGLLegoPainter::DrawPaletteAxis
void DrawPaletteAxis() const
Draw. Palette. Axis.
Definition: TGLLegoPainter.cxx:1155

TGLLegoPainter::Pan
void Pan(Int_t px, Int_t py)
Move lego or section.
Definition: TGLLegoPainter.cxx:394

TGLLevelPalette::DisableTexture
void DisableTexture() const
Disable 1D texture.
Definition: TGLUtil.cxx:4262

TGLLevelPalette::GetTexCoord
Double_t GetTexCoord(Double_t z) const
Get tex coordinate.
Definition: TGLUtil.cxx:4279

TGLLevelPalette::GeneratePalette
Bool_t GeneratePalette(UInt_t paletteSize, const Rgl::Range_t &zRange, Bool_t checkSize=kTRUE)
Try to find colors for palette.
Definition: TGLUtil.cxx:4178

TGLLevelPalette::EnableTexture
void EnableTexture(Int_t mode) const
Enable 1D texture.
Definition: TGLUtil.cxx:4243

TGLPlotBox::SetPlotBox
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

TGLPlotBox::Get3DBox
const TGLVertex3 * Get3DBox() const
Get 3D box.
Definition: TGLPlotBox.cxx:303

TGLPlotBox::DrawBox
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

TGLPlotBox::GetFrontPoint
Int_t GetFrontPoint() const
The nearest point.
Definition: TGLPlotBox.cxx:294

TGLPlotCamera
Camera for TGLPlotPainter and sub-classes.
Definition: TGLPlotCamera.h:22

TGLPlotCamera::StartPan
void StartPan(Int_t px, Int_t py)
User clicks somewhere (px, py).
Definition: TGLPlotCamera.cxx:87

TGLPlotCamera::Apply
void Apply(Double_t phi, Double_t theta) const
Applies rotations and translations before drawing.
Definition: TGLPlotCamera.cxx:141

TGLPlotCamera::SetCamera
void SetCamera() const
Viewport and projection.
Definition: TGLPlotCamera.cxx:119

TGLPlotCamera::Pan
void Pan(Int_t px, Int_t py)
Pan camera.
Definition: TGLPlotCamera.cxx:96

TGLPlotCamera::GetHeight
Int_t GetHeight() const
viewport[3]
Definition: TGLPlotCamera.cxx:178

TGLPlotCamera::SetViewVolume
void SetViewVolume(const TGLVertex3 *box)
'box' is the TGLPlotPainter's back box's coordinates.
Definition: TGLPlotCamera.cxx:55

TGLPlotCoordinates
Helper class for plot-painters holding information about axis ranges, numbers of bins and flags if ce...
Definition: TGLPlotPainter.h:310

TGLPlotCoordinates::GetZLength
Double_t GetZLength() const
Z length.
Definition: TGLPlotPainter.cxx:857

TGLPlotCoordinates::SetRanges
Bool_t SetRanges(const TH1 *hist, Bool_t errors=kFALSE, Bool_t zBins=kFALSE)
Set bin ranges, ranges.
Definition: TGLPlotPainter.cxx:750

TGLPlotCoordinates::GetYScale
Double_t GetYScale() const
Definition: TGLPlotPainter.h:382

TGLPlotCoordinates::GetXRangeScaled
const Rgl::Range_t & GetXRangeScaled() const
Scaled range.
Definition: TGLPlotPainter.cxx:866

TGLPlotCoordinates::GetXLog
Bool_t GetXLog() const
Get X log.
Definition: TGLPlotPainter.cxx:686

TGLPlotCoordinates::GetFirstXBin
Int_t GetFirstXBin() const
Definition: TGLPlotPainter.h:385

TGLPlotCoordinates::GetFirstYBin
Int_t GetFirstYBin() const
Definition: TGLPlotPainter.h:387

TGLPlotCoordinates::GetZRange
const Rgl::Range_t & GetZRange() const
Z range.
Definition: TGLPlotPainter.cxx:849

TGLPlotCoordinates::GetYRangeScaled
const Rgl::Range_t & GetYRangeScaled() const
Scaled range.
Definition: TGLPlotPainter.cxx:874

TGLPlotCoordinates::ResetModified
void ResetModified()
Reset modified.
Definition: TGLPlotPainter.cxx:734

TGLPlotCoordinates::GetYLog
Bool_t GetYLog() const
Get Y log.
Definition: TGLPlotPainter.cxx:706

TGLPlotCoordinates::GetZLog
Bool_t GetZLog() const
Get Z log.
Definition: TGLPlotPainter.cxx:726

TGLPlotCoordinates::Modified
Bool_t Modified() const
Modified.
Definition: TGLPlotPainter.cxx:742

TGLPlotCoordinates::GetXScale
Double_t GetXScale() const
Definition: TGLPlotPainter.h:381

TGLPlotCoordinates::GetZScale
Double_t GetZScale() const
Definition: TGLPlotPainter.h:383

TGLPlotCoordinates::GetNXBins
Int_t GetNXBins() const
Number of X bins.
Definition: TGLPlotPainter.cxx:768

TGLPlotCoordinates::GetZRangeScaled
const Rgl::Range_t & GetZRangeScaled() const
Scaled range.
Definition: TGLPlotPainter.cxx:882

TGLPlotCoordinates::GetYRange
const Rgl::Range_t & GetYRange() const
Y range.
Definition: TGLPlotPainter.cxx:832

TGLPlotCoordinates::GetLastYBin
Int_t GetLastYBin() const
Definition: TGLPlotPainter.h:388

TGLPlotCoordinates::GetNYBins
Int_t GetNYBins() const
Number of Y bins.
Definition: TGLPlotPainter.cxx:776

TGLPlotCoordinates::GetLastXBin
Int_t GetLastXBin() const
Definition: TGLPlotPainter.h:386

TGLPlotCoordinates::GetCoordType
EGLCoordType GetCoordType() const
Get coordinates type.
Definition: TGLPlotPainter.cxx:666

TGLPlotCoordinates::GetYLength
Double_t GetYLength() const
Y length.
Definition: TGLPlotPainter.cxx:840

TGLPlotCoordinates::GetFactor
Double_t GetFactor() const
Get factor.
Definition: TGLPlotPainter.cxx:890

TGLPlotPainter
Base class for plot-painters that provide GL rendering of various 2D and 3D histograms,...
Definition: TGLPlotPainter.h:181

TGLPlotPainter::DrawSections
void DrawSections() const
Draw sections (if any).
Definition: TGLPlotPainter.cxx:445

TGLPlotPainter::fPadTheta
Double_t fPadTheta
Definition: TGLPlotPainter.h:190

TGLPlotPainter::fDrawPalette
Bool_t fDrawPalette
Definition: TGLPlotPainter.h:219

TGLPlotPainter::fZLevels
std::vector< Double_t > fZLevels
Definition: TGLPlotPainter.h:210

TGLPlotPainter::fYAxis
TAxis * fYAxis
Definition: TGLPlotPainter.h:193

TGLPlotPainter::fXOYSectionPos
Double_t fXOYSectionPos
Definition: TGLPlotPainter.h:206

TGLPlotPainter::fPadPhi
Double_t fPadPhi
Definition: TGLPlotPainter.h:189

TGLPlotPainter::fMousePosition
TPoint fMousePosition
Definition: TGLPlotPainter.h:203

TGLPlotPainter::kZAxis
@ kZAxis
Definition: TGLPlotPainter.h:265

TGLPlotPainter::kXAxis
@ kXAxis
Definition: TGLPlotPainter.h:263

TGLPlotPainter::RestoreModelviewMatrix
void RestoreModelviewMatrix() const
Definition: TGLPlotPainter.cxx:606

TGLPlotPainter::fSelectedPart
Int_t fSelectedPart
Definition: TGLPlotPainter.h:202

TGLPlotPainter::fSelectionPass
Bool_t fSelectionPass
Definition: TGLPlotPainter.h:201

TGLPlotPainter::fXOZSectionPos
Double_t fXOZSectionPos
Definition: TGLPlotPainter.h:204

TGLPlotPainter::fBoxCut
TGLBoxCut fBoxCut
Definition: TGLPlotPainter.h:208

TGLPlotPainter::Paint
virtual void Paint()
Draw lego/surf/whatever you can.
Definition: TGLPlotPainter.cxx:152

TGLPlotPainter::fCoord
TGLPlotCoordinates * fCoord
Definition: TGLPlotPainter.h:196

TGLPlotPainter::fBackBox
TGLPlotBox fBackBox
Definition: TGLPlotPainter.h:207

TGLPlotPainter::fHist
TH1 * fHist
Definition: TGLPlotPainter.h:191

TGLPlotPainter::SaveProjectionMatrix
void SaveProjectionMatrix() const
Definition: TGLPlotPainter.cxx:598

TGLPlotPainter::SaveModelviewMatrix
void SaveModelviewMatrix() const
Definition: TGLPlotPainter.cxx:590

TGLPlotPainter::MoveSection
void MoveSection(Int_t px, Int_t py)
Create dynamic profile using selected plane.
Definition: TGLPlotPainter.cxx:373

TGLPlotPainter::fUpdateSelection
Bool_t fUpdateSelection
Definition: TGLPlotPainter.h:200

TGLPlotPainter::fHighColor
Bool_t fHighColor
Definition: TGLPlotPainter.h:211

TGLPlotPainter::fCamera
TGLPlotCamera * fCamera
Definition: TGLPlotPainter.h:197

TGLPlotPainter::fXAxis
TAxis * fXAxis
Definition: TGLPlotPainter.h:192

TGLPlotPainter::RestoreProjectionMatrix
void RestoreProjectionMatrix() const
Definition: TGLPlotPainter.cxx:614

TGLPlotPainter::fSelectionBase
Int_t fSelectionBase
Definition: TGLPlotPainter.h:218

TGLPlotPainter::fYOZSectionPos
Double_t fYOZSectionPos
Definition: TGLPlotPainter.h:205

TGLPlotPainter::fZAxis
TAxis * fZAxis
Definition: TGLPlotPainter.h:194

TGLVertex3
3 component (x/y/z) vertex class.
Definition: TGLUtil.h:83

TGLVertex3::X
Double_t X() const
Definition: TGLUtil.h:118

TGLVertex3::Z
Double_t Z() const
Definition: TGLUtil.h:122

TGLVertex3::Y
Double_t Y() const
Definition: TGLUtil.h:120

TH1
The TH1 histogram class.
Definition: TH1.h:56

TH1::GetBarWidth
virtual Float_t GetBarWidth() const
Definition: TH1.h:252

TH1::GetBarOffset
virtual Float_t GetBarOffset() const
Definition: TH1.h:251

TH1::GetBinError
virtual Double_t GetBinError(Int_t bin) const
Return value of error associated to bin number bin.
Definition: TH1.cxx:8384

TH1::kUserContour
@ kUserContour
user specified contour levels
Definition: TH1.h:161

TH1::GetBinContent
virtual Double_t GetBinContent(Int_t bin) const
Return content of bin number bin.
Definition: TH1.cxx:4790

TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47

TObject::TestBit
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:172

TObject::ResetBit
void ResetBit(UInt_t f)
Definition: TObject.h:171

TPoint::fY
SCoord_t fY
Definition: TPoint.h:36

TPoint::fX
SCoord_t fX
Definition: TPoint.h:35

TString
Basic string class.
Definition: TString.h:131

TString::Length
Ssiz_t Length() const
Definition: TString.h:405

TString::Data
const char * Data() const
Definition: TString.h:364

TString::Form
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2264

TString::Index
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition: TString.h:634

TStyle::GetLegoInnerR
Float_t GetLegoInnerR() const
Definition: TStyle.h:227

TStyle::GetNumberContours
Int_t GetNumberContours() const
Definition: TStyle.h:228

TVirtualX::kCopy
@ kCopy
Definition: TVirtualX.h:56

Rgl::DrawTrapezoid
void DrawTrapezoid(const Double_t ver[][2], Double_t zMin, Double_t zMax, Bool_t color=kTRUE)
Definition: TGLUtil.cxx:3365

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:3435

Rgl::gNullEmission
const Float_t gNullEmission[]
Definition: TGLUtil.cxx:2864

Rgl::ObjectIDToColor
void ObjectIDToColor(Int_t objectID, Bool_t highColor)
Object id encoded as rgb triplet.
Definition: TGLUtil.cxx:2908

Rgl::SetZLevels
void SetZLevels(TAxis *zAxis, Double_t zMin, Double_t zMax, Double_t zScale, std::vector< Double_t > &zLevels)
Definition: TGLUtil.cxx:3837

Rgl::DrawPalette
void DrawPalette(const TGLPlotCamera *camera, const TGLLevelPalette &palette)
Draw. Palette.
Definition: TGLPlotPainter.cxx:2118

Rgl::DrawPaletteAxis
void DrawPaletteAxis(const TGLPlotCamera *camera, const Range_t &minMax, Bool_t logZ)
Definition: TGLPlotPainter.cxx:2224

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:3512

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:3261

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:3315

Rgl::Range_t
std::pair< Double_t, Double_t > Range_t
Definition: TGLUtil.h:1193

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:3024

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:3151

Rgl::gOrangeEmission
const Float_t gOrangeEmission[]
Definition: TGLUtil.cxx:2861

TGeoUnit::second
static constexpr double second
Definition: TGeoSystemOfUnits.h:151

TMath::Max
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:212

TMath::Min
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:180

TMath::Cos
Double_t Cos(Double_t)
Definition: TMath.h:629

TMath::Pi
constexpr Double_t Pi()
Definition: TMath.h:38

TMath::Sin
Double_t Sin(Double_t)
Definition: TMath.h:625

TMath::Log10
Double_t Log10(Double_t x)
Definition: TMath.h:752

TMath::TwoPi
constexpr Double_t TwoPi()
Definition: TMath.h:45

first
Definition: first.py:1

std
STL namespace.

std::swap
void swap(nlohmann::json &j1, nlohmann::json &j2) noexcept(is_nothrow_move_constructible< nlohmann::json >::value and is_nothrow_move_assignable< nlohmann::json >::value)
exchanges the values of two JSON objects
Definition: json.hpp:12929