Logo ROOT  
Reference Guide
TGLCameraOverlay.cxx
Go to the documentation of this file.
1// @(#)root/gl:$Id$
2// Author: Alja Mrak-Tadel 2007
3
4/*************************************************************************
5 * Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#include "TGLIncludes.h"
13#include "TGLCameraOverlay.h"
14#include "TGLViewer.h"
15#include "TGLCamera.h"
16#include "TGLSelectRecord.h"
17#include "TGLUtil.h"
18#include "TGLRnrCtx.h"
19#include "TGLAxisPainter.h"
20
21#include "TMath.h"
22#include "TAxis.h"
23#include "THLimitsFinder.h"
24
25/** \class TGLCameraOverlay
26\ingroup opengl
27A GL overlay element which displays camera furstum.
28*/
29
31
32////////////////////////////////////////////////////////////////////////////////
33
36
37 fShowOrthographic(showOrtho),
38 fShowPerspective(showPersp),
39
40 fOrthographicMode(kAxis),
41 fPerspectiveMode(kPlaneIntersect),
42
43 fAxisPainter(0),
44 fAxis(0),
45 fAxisExtend(0.9),
46 fUseAxisColors(kFALSE),
47
48 fExternalRefPlane(),
49 fUseExternalRefPlane(kFALSE)
50{
51 // Constructor.
52
53 fFrustum[0] = fFrustum[1] = fFrustum[2] = fFrustum[3] = 0;
54
55 fAxis = new TAxis();
56 fAxis->SetNdivisions(710);
57 fAxis->SetLabelSize(0.018);
58 fAxis->SetLabelOffset(0.01);
61
65}
66
67////////////////////////////////////////////////////////////////////////////////
68/// Destructor.
69
71{
72 delete fAxisPainter;
73 delete fAxis;
74}
75
76////////////////////////////////////////////////////////////////////////////////
77/// Get axis attributes.
78
80{
81 return dynamic_cast<TAttAxis*>(fAxis);
82}
83
84////////////////////////////////////////////////////////////////////////////////
85/// Set frustum values from given camera.
86
88{
89 TGLVector3 absRef(1., 1., 1.); // needed in case if orthographic camera is negative
90 Float_t l = -cam.FrustumPlane(TGLCamera::kLeft).D() * Dot(cam.GetCamBase().GetBaseVec(2), absRef);
91 Float_t r = cam.FrustumPlane(TGLCamera::kRight).D() * Dot(cam.GetCamBase().GetBaseVec(2), absRef);
94
95 fFrustum[0] = l;
96 fFrustum[1] = b;
97 fFrustum[2] = r;
98 fFrustum[3] = t;
99}
100
101////////////////////////////////////////////////////////////////////////////////
102/// Draw cross section coordinates in top right corner of screen.
103
105{
106 TGLCamera &cam = rnrCtx.RefCamera();
107 // get eye line
108 const TGLMatrix& mx = cam.GetCamBase() * cam.GetCamTrans();
110 TGLVertex3 p = d + mx.GetBaseVec(1);
111 TGLLine3 line(d, p);
112 // get ref plane
115 // get intersection
116 std::pair<Bool_t, TGLVertex3> intersection;
117 intersection = Intersection(rp, line, kTRUE);
118
119 if (intersection.first)
120 {
121 TGLVertex3 v = intersection.second;
122
123 glMatrixMode(GL_PROJECTION);
124 glPushMatrix();
125 glLoadIdentity();
126
127 glMatrixMode(GL_MODELVIEW);
128 glPushMatrix();
129 glLoadIdentity();
130
131 TGLRect &vp = rnrCtx.GetCamera()->RefViewport();
132 TGLFont font;
133 Int_t fs = TMath::Nint(TMath::Sqrt(vp.Width()*vp.Width() + vp.Height()*vp.Height())*0.02);
134 rnrCtx.RegisterFontNoScale(fs, "arial", TGLFont::kPixmap, font);
135 const char* txt = Form("(%f, %f, %f)", v[0], v[1], v[2]);
136 TGLUtil::Color(rnrCtx.ColorSet().Markup());
137 font.Render(txt, 0.98, 0.98, 0, TGLFont::kRight, TGLFont::kBottom);
138
139 // render cross
141 Float_t w = 0.02; // cross size
142 Float_t ce = 0.15; // empty space
143 glBegin(GL_LINES);
144 glVertex2f(0 +w*ce, 0);
145 glVertex2f(0 +w, 0);
146
147 glVertex2f(0 -w*ce, 0);
148 glVertex2f(0 -w, 0);
149
150 Float_t h = w*vp.Width()/vp.Height();
151 glVertex2f(0, 0 +h*ce);
152 glVertex2f(0, 0 +h);
153
154 glVertex2f(0, 0 -h*ce);
155 glVertex2f(0, 0 -h);
156 glEnd();
157
158 glPopMatrix();
159 glMatrixMode(GL_PROJECTION);
160 glPopMatrix();
161 glMatrixMode(GL_MODELVIEW);
162 }
163}
164
165////////////////////////////////////////////////////////////////////////////////
166/// Draw axis on four edges and a transparent grid.
167
169{
172
173 Color_t lineColor = fUseAxisColors ? fAxis->GetAxisColor() : rnrCtx.ColorSet().Markup().GetColorIndex();
174
175 // font size calculated relative to viewport diagonal
176 GLint vp[4]; glGetIntegerv(GL_VIEWPORT, vp);
177 Float_t rl = 0.5 *((vp[2]-vp[0]) + (vp[3]-vp[1]));
178 Int_t fsizePx = (Int_t)(fAxis->GetLabelSize()*rl);
179 // tick length
180 Float_t tlY = 0.015*rl/(vp[2]-vp[0]);
181 Float_t tlX = 0.015*rl/(vp[3]-vp[1]);
182 // corner vectors
183 Float_t minX, maxX;
184 TGLVector3 xdir = rnrCtx.RefCamera().GetCamBase().GetBaseVec(2); xdir.Normalise(); // left
185 if (fFrustum[2] > fFrustum[0] )
186 {
187 minX = fFrustum[0];
188 maxX = fFrustum[2];
189 }
190 else {
191 xdir = -xdir;
192 minX = fFrustum[2];
193 maxX = fFrustum[0];
194 }
195
196 TGLVector3 ydir = rnrCtx.RefCamera().GetCamBase().GetBaseVec(3); ydir.Normalise(); // up
197 TGLVector3 vy1 = ydir * fFrustum[1];
198 TGLVector3 vy2 = ydir * fFrustum[3];
199
200 TGLVector3 vx1 = xdir * minX;
201 TGLVector3 vx2 = xdir * maxX;
202 // range
203 Double_t rngY = fFrustum[3] - fFrustum[1];
204 Double_t rngX = maxX - minX;
205 Double_t off = TMath::Sqrt((rngX*rngX)+(rngY*rngY)) * 0.03;
206 Double_t minY = fFrustum[1] + off;
207 Double_t maxY = fFrustum[3] - off;
208 minX += off;
209 maxX -= off;
210
211 // grid lines
212 Char_t alpha = 80; //primary
213 Char_t alpha2 = 90; //secondary
214 Int_t secSteps = fAxis->GetNdivisions() % 100;
215 GLushort stipple = 0x5555; // 33333 more rare
216
217 // horizontal X
218 //
220 fAxis->SetTickLength(tlX);
221 fAxisPainter->RefDir() = xdir;
222 fAxis->SetLimits(minX, maxX);
223 fAxisPainter->RefTMOff(0) = ydir*rngY;
224
225 // bottom
226 glPushMatrix();
227 glTranslated(vy1.X(), vy1.Y(), vy1.Z());
229 fAxisPainter->PaintAxis(rnrCtx, fAxis);
230 glPopMatrix();
231
232 // top
233 glPushMatrix();
234 glTranslated(vy2.X(), vy2.Y(), vy2.Z());
239 glPopMatrix();
240
242 if (grid)
243 {
245 TGLVector3 tmp;
246 // draw label vertical lines
247 TGLUtil::ColorTransparency(lineColor, alpha);
248 glBegin(GL_LINES);
249 for (TGLAxisPainter::LabVec_t::iterator i = labs.begin(); i != labs.end(); ++i) {
250 tmp = vy1 + xdir * (i->first);
251 glVertex3dv(tmp.Arr());
252 tmp = vy2 + xdir * (i->first);
253 glVertex3dv(tmp.Arr());
254 }
255 glEnd();
256
257 // secondary tick mark lines
258 if (labs.size() > 1)
259 {
260 TGLUtil::ColorTransparency(lineColor, alpha2);
261 glPushAttrib(GL_ENABLE_BIT | GL_LINE_BIT);
262 glEnable(GL_LINE_STIPPLE);
263 glLineStipple(1, stipple);
264
265 glBegin(GL_LINES);
266 Int_t ondiv = 0;
267 Double_t omin = 0, omax = 0, bw1 = 0;
268 THLimitsFinder::Optimize(labs[0].second, labs[1].second, secSteps, omin, omax, ondiv, bw1);
269 Double_t val = labs[0].second;
270 while (val < fFrustum[2])
271 {
272 for (Int_t k=0; k<ondiv; k++)
273 {
274 val += bw1;
275 tmp = vy1 + xdir * val;
276 glVertex3dv(tmp.Arr());
277 tmp = vy2 + xdir * val;
278 glVertex3dv(tmp.Arr());
279 }
280 }
281 val = labs[0].second - bw1;
282 while(val > fFrustum[0])
283 {
284 tmp = vy1 + xdir * val;
285 glVertex3dv(tmp.Arr());
286 tmp = vy2 + xdir * val;
287 glVertex3dv(tmp.Arr());
288 val -= bw1;
289 }
290 glEnd();
291 glPopAttrib();
292 }
293 } // draw grid
294
295 //
296 // vertical Y axis
297 //
298
299 fAxis->SetTickLength(tlY);
300 fAxisPainter->RefDir() = ydir;
301 fAxis->SetLimits(minY, maxY);
302 fAxisPainter->RefTMOff(0) = xdir*rngX;
303 // left
304 glPushMatrix();
305 glTranslated(vx1.X(), vx1.Y(), vx1.Z());
307 fAxisPainter->PaintAxis(rnrCtx, fAxis);
308 glPopMatrix();
309 // right
310 glPushMatrix();
311 glTranslated(vx2.X(), vx2.Y(), vx2.Z());
316 glPopMatrix();
317
318 if (grid)
319 {
321 TGLVector3 tmp;
322 // draw label horizontal lines
323 TGLUtil::ColorTransparency(lineColor, alpha);
324 glBegin(GL_LINES);
325 for (TGLAxisPainter::LabVec_t::iterator i = labs.begin(); i != labs.end(); ++i) {
326 tmp = vx1 + ydir *(i->first);
327 glVertex3dv(tmp.Arr());
328 tmp = vx2 + ydir *(i->first);
329 glVertex3dv(tmp.Arr());
330 }
331 glEnd();
332
333 // secondary tick mark lines
334 if (labs.size() > 1)
335 {
336 TGLUtil::ColorTransparency(lineColor, alpha2);
337 glPushAttrib(GL_ENABLE_BIT | GL_LINE_BIT);
338 glEnable(GL_LINE_STIPPLE);
339 glLineStipple(1, stipple);
340
341 glBegin(GL_LINES);
342 Int_t ondiv;
343 Double_t omin = 0, omax = 0, bw1 = 0;
344 Double_t val = 0;
345 THLimitsFinder::Optimize(labs[0].second, labs[1].second, secSteps, omin, omax, ondiv, bw1);
346 val = labs[0].second;
347 while(val < fFrustum[3])
348 {
349 for(Int_t k=0; k<ondiv; k++)
350 {
351 val += bw1;
352 tmp = vx1 + ydir *val;
353 glVertex3dv(tmp.Arr());
354 tmp = vx2 + ydir * val;
355 glVertex3dv(tmp.Arr());
356 }
357 }
358
359 val = labs[0].second - bw1;
360 while(val > fFrustum[1])
361 {
362 tmp = vx1 + ydir *val;
363 glVertex3dv(tmp.Arr());
364 tmp = vx2 + ydir * val;
365 glVertex3dv(tmp.Arr());
366 val -= bw1;
367 }
368 glEnd();
369 glPopAttrib();
370 }
371 } // draw grid
372}
373
374////////////////////////////////////////////////////////////////////////////////
375/// Show frustum size with fixed screen line length and printed value.
376
378{
379 // factors 10, 5 and 2 are allowed
380 Double_t wfrust = TMath::Abs(fFrustum[2]-fFrustum[0]);
381 Float_t barsize= 0.14* wfrust;
383 Double_t fact = barsize/TMath::Power(10, exp);
384 Double_t red;
385 if (fact > 5)
386 {
387 red = 5*TMath::Power(10, exp);
388 }
389 else if (fact > 2)
390 {
391 red = 2*TMath::Power(10, exp);
392 } else
393 {
394 red = TMath::Power(10, exp);
395 }
396
398 TGLVector3 xdir = rnrCtx.RefCamera().GetCamBase().GetBaseVec(2); // left
399 TGLVector3 ydir = rnrCtx.RefCamera().GetCamBase().GetBaseVec(3); // up
400 xdir.Normalise();
401 ydir.Normalise();
402
404
405 const char* txt = Form("%.*f", (exp < 0) ? -exp : 0, red);
406 Float_t bb[6];
407 TGLFont font;
408 rnrCtx.RegisterFont(12, "arial", TGLFont::kPixmap, font);
409 font.BBox(txt, bb[0], bb[1], bb[2], bb[3], bb[4], bb[5]);
410 TGLRect &vp = rnrCtx.GetCamera()->RefViewport();
411 Double_t mH = (fFrustum[3]-fFrustum[1])*bb[4]/vp.Height();
412 glPushMatrix();
413 v = xdir*(fFrustum[2]-barsize) + ydir*(fFrustum[3] - mH*1.5);
414 glTranslated(v.X(), v.Y(), v.Z());
415 glRasterPos2i(0,0);
416 font.Render(txt);
417 glPopMatrix();
418
419 glPushAttrib(GL_ENABLE_BIT | GL_LINE_BIT);
421 glPushMatrix();
422 Float_t xt = fFrustum[2] - 1.1*barsize;
423 Float_t yt = fFrustum[3] - 2.1*mH;
424 v = xdir*xt + ydir*yt;
425 glTranslated(v.X(), v.Y(), v.Z());
426
427 glBegin(GL_LINES);
428 // horizontal static
429 v = red*xdir;
430 glVertex3dv(v.Arr());
431 v = barsize*xdir;
432 glVertex3dv(v.Arr());
433 // corner bars end
434 v = xdir*barsize + ydir*mH;
435 glVertex3dv(v.Arr());
436 v = xdir*barsize - ydir*mH;
437 glVertex3dv(v.Arr());
438 // corner bar start
440 v = ydir*mH;
441 glVertex3dv(v.Arr());
442 v.Negate();
443 glVertex3dv(v.Arr());
444 // marker pointer
445 v = red*ydir;
446 glVertex3dv(v.Arr());
447 v += ydir*mH;
448 glVertex3dv(v.Arr());
449 //marker line
450 glVertex3d(0, 0., 0.);
451 v = red*xdir;
452 glVertex3dv(v.Arr());
453 glEnd();
454 glPopAttrib();
455 glPopMatrix();
456}
457
458////////////////////////////////////////////////////////////////////////////////
459/// Display coordinates info of current frustum.
460
462{
463 TGLCamera &cam = rnrCtx.RefCamera();
464
465 if (rnrCtx.Selection() ||
466 (cam.IsPerspective() && ! fShowPerspective) ||
468 {
469 return;
470 }
471
472 glPushAttrib(GL_ENABLE_BIT | GL_LINE_BIT);
473 glEnable(GL_BLEND);
474 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
475
476 TGLUtil::Color(rnrCtx.ColorSet().Markup());
477 TGLCapabilitySwitch lights_off(GL_LIGHTING, kFALSE);
478 Float_t old_depth_range[2];
479 glGetFloatv(GL_DEPTH_RANGE, old_depth_range);
480
481 SetFrustum(cam);
482
483 if (cam.IsOrthographic())
484 {
485 switch (fOrthographicMode)
486 {
487 case kBar:
488 glDepthRange(0, 0.1);
489 RenderBar(rnrCtx);
490 break;
491 case kAxis:
492 glDepthRange(0, 0.1);
493 RenderAxis(rnrCtx, kFALSE);
494 break;
495 case kGridFront:
496 glDepthRange(0, 0.1);
497 RenderAxis(rnrCtx, kTRUE);
498 break;
499 case kGridBack:
500 glDepthRange(1, 0.9);
501 RenderAxis(rnrCtx, kTRUE);
502 break;
503 default:
504 break;
505 };
506 }
507 else
508 {
509 RenderPlaneIntersect(rnrCtx);
510 }
511
512 glDepthRange(old_depth_range[0], old_depth_range[1]);
513 glPopAttrib();
514}
#define GL_LINES
Definition: GL_glu.h:284
unsigned short GLushort
Definition: GL_glu.h:274
ROOT::R::TRInterface & r
Definition: Object.C:4
#define d(i)
Definition: RSha256.hxx:102
#define b(i)
Definition: RSha256.hxx:100
#define h(i)
Definition: RSha256.hxx:106
int Int_t
Definition: RtypesCore.h:43
char Char_t
Definition: RtypesCore.h:31
const Bool_t kFALSE
Definition: RtypesCore.h:90
double Double_t
Definition: RtypesCore.h:57
short Color_t
Definition: RtypesCore.h:81
float Float_t
Definition: RtypesCore.h:55
const Bool_t kTRUE
Definition: RtypesCore.h:89
#define ClassImp(name)
Definition: Rtypes.h:361
@ kGray
Definition: Rtypes.h:63
@ kRed
Definition: Rtypes.h:64
std::pair< Bool_t, TGLLine3 > Intersection(const TGLPlane &p1, const TGLPlane &p2)
Find 3D line interestion of this plane with 'other'.
Definition: TGLUtil.cxx:517
double exp(double)
char * Form(const char *fmt,...)
@ kAxis
Manages histogram axis attributes.
Definition: TAttAxis.h:18
virtual Int_t GetNdivisions() const
Definition: TAttAxis.h:36
virtual Color_t GetAxisColor() const
Definition: TAttAxis.h:37
virtual void SetAxisColor(Color_t color=1, Float_t alpha=1.)
Set color of the line axis and tick marks.
Definition: TAttAxis.cxx:163
virtual void SetLabelSize(Float_t size=0.04)
Set size of axis labels.
Definition: TAttAxis.cxx:204
virtual void SetLabelOffset(Float_t offset=0.005)
Set distance between the axis and the labels.
Definition: TAttAxis.cxx:193
virtual Float_t GetLabelSize() const
Definition: TAttAxis.h:41
virtual void SetTickLength(Float_t length=0.03)
Set tick mark length.
Definition: TAttAxis.cxx:280
virtual void SetNdivisions(Int_t n=510, Bool_t optim=kTRUE)
Set the number of divisions for this axis.
Definition: TAttAxis.cxx:229
virtual void SetLabelColor(Color_t color=1, Float_t alpha=1.)
Set color of labels.
Definition: TAttAxis.cxx:173
Class to manage histogram axis.
Definition: TAxis.h:30
virtual void SetLimits(Double_t xmin, Double_t xmax)
Definition: TAxis.h:154
void RnrLabels() const
Render label reading prepared list ov value-pos pairs.
void RnrLines() const
Render axis main line and tick-marks.
TGLVector3 & RefDir()
void SetLabelAlign(TGLFont::ETextAlignH_e, TGLFont::ETextAlignV_e)
Set label align.
std::vector< Lab_t > LabVec_t
LabVec_t & RefLabVec()
void SetUseAxisColors(Bool_t x)
void SetAttAxis(TAttAxis *a)
void SetLabelPixelFontSize(Int_t fs)
TGLVector3 & RefTMOff(Int_t i)
void SetFontMode(TGLFont::EMode m)
void PaintAxis(TGLRnrCtx &ctx, TAxis *ax)
GL render TAxis.
A GL overlay element which displays camera furstum.
void RenderAxis(TGLRnrCtx &rnrCtx, Bool_t drawGrid)
Draw axis on four edges and a transparent grid.
TGLAxisPainter * fAxisPainter
TGLPlane fExternalRefPlane
Double_t fFrustum[4]
void SetFrustum(TGLCamera &cam)
Set frustum values from given camera.
virtual void Render(TGLRnrCtx &rnrCtx)
Display coordinates info of current frustum.
void RenderPlaneIntersect(TGLRnrCtx &rnrCtx)
Draw cross section coordinates in top right corner of screen.
TAttAxis * GetAttAxis()
Get axis attributes.
TGLCameraOverlay(const TGLCameraOverlay &)
void RenderBar(TGLRnrCtx &rnrCtx)
Show frustum size with fixed screen line length and printed value.
virtual ~TGLCameraOverlay()
Destructor.
Abstract base camera class - concrete classes for orthographic and perspective cameras derive from it...
Definition: TGLCamera.h:43
virtual Bool_t IsPerspective() const
Definition: TGLCamera.h:118
const TGLMatrix & GetCamBase() const
Definition: TGLCamera.h:165
const TGLMatrix & GetCamTrans() const
Definition: TGLCamera.h:166
virtual Bool_t IsOrthographic() const
Definition: TGLCamera.h:117
const TGLPlane & FrustumPlane(EFrustumPlane plane) const
Definition: TGLCamera.h:218
TGLRect & RefViewport()
Definition: TGLCamera.h:127
TGLColor & Foreground()
Definition: TGLUtil.h:851
TGLColor & Markup()
Definition: TGLUtil.h:853
Color_t GetColorIndex() const
Returns color-index representing the color.
Definition: TGLUtil.cxx:1218
A wrapper class for FTFont.
void BBox(const char *txt, Float_t &llx, Float_t &lly, Float_t &llz, Float_t &urx, Float_t &ury, Float_t &urz) const
Get bounding box.
void Render(const char *txt, Double_t x, Double_t y, Double_t angle, Double_t mgn) const
3D space, fixed length, line class, with direction / length 'vector', passing through point 'vertex'.
Definition: TGLUtil.h:386
16 component (4x4) transform matrix - column MAJOR as per GL.
Definition: TGLUtil.h:597
TGLVector3 GetBaseVec(Int_t b) const
Definition: TGLUtil.h:753
TGLVector3 GetTranslation() const
Return the translation component of matrix.
Definition: TGLUtil.cxx:795
An overlay element.
Definition: TGLOverlay.h:23
3D plane class - of format Ax + By + Cz + D = 0
Definition: TGLUtil.h:524
Double_t D() const
Definition: TGLUtil.h:555
Viewport (pixel base) 2D rectangle class.
Definition: TGLUtil.h:421
Int_t Height() const
Definition: TGLUtil.h:451
Int_t Width() const
Definition: TGLUtil.h:449
The TGLRnrCtx class aggregates data for a given redering context as needed by various parts of the RO...
Definition: TGLRnrCtx.h:41
void RegisterFontNoScale(Int_t size, Int_t file, Int_t mode, TGLFont &out)
Get font in the GL rendering context.
Definition: TGLRnrCtx.cxx:367
TGLColorSet & ColorSet()
Return reference to current color-set (top of the stack).
Definition: TGLRnrCtx.cxx:278
TGLCamera & RefCamera()
Definition: TGLRnrCtx.h:157
void RegisterFont(Int_t size, Int_t file, Int_t mode, TGLFont &out)
Get font in the GL rendering context.
Definition: TGLRnrCtx.cxx:384
TGLCamera * GetCamera()
Definition: TGLRnrCtx.h:156
Bool_t Selection() const
Definition: TGLRnrCtx.h:222
static void ColorTransparency(Color_t color_index, Char_t transparency=0)
Set color from color_index and ROOT-style transparency (default 0).
Definition: TGLUtil.cxx:1736
static void Color(const TGLColor &color)
Set color from TGLColor.
Definition: TGLUtil.cxx:1692
static Float_t LineWidth()
Get the line-width, taking the global scaling into account.
Definition: TGLUtil.cxx:1938
3 component (x/y/z) vector class.
Definition: TGLUtil.h:247
void Normalise()
Definition: TGLUtil.h:303
3 component (x/y/z) vertex class.
Definition: TGLUtil.h:83
Double_t X() const
Definition: TGLUtil.h:118
Double_t Z() const
Definition: TGLUtil.h:122
Double_t * Arr()
Definition: TGLUtil.h:126
void Negate()
Definition: TGLUtil.h:140
Double_t Y() const
Definition: TGLUtil.h:120
static void Optimize(Double_t A1, Double_t A2, Int_t nold, Double_t &BinLow, Double_t &BinHigh, Int_t &nbins, Double_t &BWID, Option_t *option="")
Static function to compute reasonable axis limits.
TLine * line
static constexpr double second
Int_t Nint(T x)
Round to nearest integer. Rounds half integers to the nearest even integer.
Definition: TMath.h:703
Double_t Floor(Double_t x)
Definition: TMath.h:693
Double_t Sqrt(Double_t x)
Definition: TMath.h:681
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Definition: TMath.h:725
Double_t Log10(Double_t x)
Definition: TMath.h:754
Short_t Abs(Short_t d)
Definition: TMathBase.h:120
#define Dot(u, v)
Definition: normal.c:49
auto * l
Definition: textangle.C:4