Logo ROOT  
Reference Guide
TEveCaloLegoOverlay.cxx
Go to the documentation of this file.
1// @(#)root/eve:$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 "TEveCaloLegoOverlay.h"
13#include "TEveCaloLegoGL.h"
14
15#include "TAxis.h"
16#include "TColor.h"
17#include "TROOT.h"
18#include "THLimitsFinder.h"
19
20#include "TGLRnrCtx.h"
21#include "TGLIncludes.h"
22#include "TGLSelectRecord.h"
23#include "TGLUtil.h"
24#include "TGLViewerBase.h"
25#include "TGLCamera.h"
26#include "TGLAxisPainter.h"
27#include "TGLFontManager.h"
28
29#include "TEveCalo.h"
30#include "TEveCaloData.h"
31#include "TEveRGBAPalette.h"
32
33#include <KeySymbols.h>
34
35
36/** \class TEveCaloLegoOverlay
37\ingroup TEve
38GL-overlay control GUI for TEveCaloLego.
39*/
40
42
43////////////////////////////////////////////////////////////////////////////////
44/// Constructor.
45
48
49 fCalo(0),
50
51 fShowScales(kTRUE),
52 fScaleColor(-1), fScaleTransparency(0),
53 fScaleCoordX(0.85), fScaleCoordY(0.65),
54 fScaleW(0), fScaleH(0),
55 fCellX(-1), fCellY(-1),
56
57 fFrameColor(-1), fFrameLineTransp(70), fFrameBgTransp(90),
58
59 fMouseX(0), fMouseY(0),
60 fInDrag(kFALSE),
61
62 fHeaderSelected(kFALSE),
63
64 fPlaneAxis(0), fAxisPlaneColor(kGray),
65 fShowPlane(kFALSE),
66
67 fMenuW(0.08),
68 fButtonW(0.5),
69 fShowSlider(kFALSE),
70 fSliderH(0.6),
71 fSliderPosY(0.15),
72 fSliderVal(0),
73
74 fActiveID(-1), fActiveCol(kRed-4)
75{
76 fPlaneAxis = new TAxis();
77}
78
79/******************************************************************************/
80// Virtual event handlers from TGLOverlayElement
81/******************************************************************************/
82
84{
85 // Set height of horizontal plane in the calorimeter.
86
87 TGLRect& wprt = rnrCtx.RefCamera().RefViewport();
88 fSliderVal = (1 -event->fY*1./wprt.Height() -fSliderPosY)/fSliderH;
89
90 if (fSliderVal < 0 )
91 fSliderVal = 0;
92 else if (fSliderVal > 1)
93 fSliderVal = 1;
94
96
97 return kTRUE;
98}
99
100////////////////////////////////////////////////////////////////////////////////
101/// Handle overlay event.
102/// Return TRUE if event was handled.
103
105 TGLOvlSelectRecord & selRec,
106 Event_t * event)
107{
108 if (selRec.GetN() < 2) return kFALSE;
109
110
111 if (rnrCtx.RefCamera().IsOrthographic())
112 {
113 switch (event->fType)
114 { case kButtonPress:
115 {
116 fMouseX = event->fX;
117 fMouseY = event->fY;
118 fInDrag = kTRUE;
119 return kTRUE;
120 }
121 case kButtonRelease:
122 {
123 fInDrag = kFALSE;
124 return kTRUE;
125 }
126 case kMotionNotify:
127 {
128 if (fInDrag)
129 {
130 const TGLRect& vp = rnrCtx.RefCamera().RefViewport();
131 fScaleCoordX += (Float_t)(event->fX - fMouseX) / vp.Width();
132 fScaleCoordY -= (Float_t)(event->fY - fMouseY) / vp.Height();
133 fMouseX = event->fX;
134 fMouseY = event->fY;
135 // Make sure we don't go offscreen (use fDraw variables set in draw)
136 if (fScaleCoordX < 0)
137 fScaleCoordX = 0;
138 else if (fScaleCoordX + fScaleW > 1.0f)
139 fScaleCoordX = 1.0f - fScaleW;
140 if (fScaleCoordY < 0)
141 fScaleCoordY = 0;
142 else if (fScaleCoordY + fScaleH > 1.0f)
143 fScaleCoordY = 1.0f - fScaleH;
144 }
145 return kTRUE;
146 }
147 default:
148 break;
149 }
150 }
151
152 else
153 {
154 switch (event->fType)
155 {
156 case kMotionNotify:
157 {
158 Int_t item = selRec.GetN() < 2 ? -1 : (Int_t)selRec.GetItem(1);
159 if (fActiveID != item) {
160 fActiveID = item;
161 return kTRUE;
162 } else {
163 if (fActiveID == 2 && event->fState == 256)
164 return SetSliderVal(event, rnrCtx);
165
166 return kFALSE;
167 }
168 break;
169 }
170 case kButtonPress:
171 {
172 if (event->fCode != kButton1) {
173 return kFALSE;
174 }
175 switch (selRec.GetItem(1))
176 {
177 case 1:
180 break;
181 case 2:
182 return SetSliderVal(event, rnrCtx);
183 case 3:
185 default:
186 break;
187 }
188 }
189 default:
190 break;
191 }
192 }
193
194 return kFALSE;
195}
196
197////////////////////////////////////////////////////////////////////////////////
198/// Mouse has entered overlay area.
199
201{
202 return kTRUE;
203}
204
205////////////////////////////////////////////////////////////////////////////////
206/// Mouse has left overlay area.
207
209{
210 fActiveID = -1;
211}
212
213////////////////////////////////////////////////////////////////////////////////
214/// Set color and transparency of scales.
215
217{
218 fScaleColor = colIdx;
219 fScaleTransparency = transp;
220}
221
222////////////////////////////////////////////////////////////////////////////////
223/// Set scale coordinates in range [0,1].
224
226{
227 fScaleCoordX = x;
228 fScaleCoordY = y;
229}
230
231////////////////////////////////////////////////////////////////////////////////
232/// Set frame attributes.
233
234void TEveCaloLegoOverlay:: SetFrameAttribs(Color_t frameColor, Char_t lineTransp, Char_t bgTransp)
235{
236 fFrameColor = frameColor;
237 fFrameLineTransp = lineTransp;
238 fFrameBgTransp = bgTransp;
239}
240
241//==============================================================================
243{
244 // Render text on top right corner of the screen.
245
246 TGLRect &vp = rnrCtx.GetCamera()->RefViewport();
247
248 TGLFont font;
249 Int_t fs = TMath::Max(TMath::Nint(vp.Height()*0.035), 12);
250 rnrCtx.RegisterFontNoScale(fs, "arial", TGLFont::kPixmap, font);
251 font.PreRender();
252 Float_t off = fs*0.2;
253 Float_t bb[6];
254 font.BBox(fHeaderTxt.Data(), bb[0], bb[1], bb[2], bb[3], bb[4], bb[5]);
255 Float_t x = vp.Width() -bb[3] -off;
256 Float_t y = vp.Height() -bb[4] -off;
257 if (rnrCtx.Selection())
258 {
259 glPushName(0);
260 glLoadName(3);
261 glBegin(GL_QUADS);
262 glVertex2f(x/vp.Width(), y/ vp.Height());
263 glVertex2f(1, y/ vp.Height());
264 glVertex2f(1, 1);
265 glVertex2f(x/vp.Width(), 1);
266 glEnd();
267 glPopName();
268 }
269 else
270 {
272 glRasterPos2i(0, 0);
273 glBitmap(0, 0, 0, 0, x, y, 0);
274 font.Render(fHeaderTxt.Data());
275 }
276 font.PostRender();
277}
278
279////////////////////////////////////////////////////////////////////////////////
280/// Render menu for plane-value and the plane if marked.
281
283{
284 glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT | GL_LINE_BIT | GL_POINT_BIT);
285 glEnable(GL_POINT_SMOOTH);
286 glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
287 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
288 glEnable(GL_POLYGON_OFFSET_FILL);
289 glPolygonOffset(0.1, 1);
290 glDisable(GL_CULL_FACE);
291 glEnable(GL_BLEND);
292 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
293
294 // move to the center of menu
295 Double_t maxVal = fCalo->GetMaxVal();
296
297 // button
298 glPushMatrix();
299 glTranslatef(1 -fMenuW, (1-fButtonW )*fMenuW*0.8, 0);
300
301 glPushName(0);
302 glLoadName(1);
303 Float_t a=0.6;
305 Float_t bw = fButtonW*fMenuW*0.5;
306 Float_t bwt = bw*0.8;
308 glBegin(GL_QUADS);
309 glVertex2f(-bw, 0);
310 glVertex2f( bw, 0);
311 glVertex2f( bwt, bh);
312 glVertex2f(-bwt, bh);
313 glEnd();
314
315
317 glBegin(GL_LINES);
319 glVertex2f(0, 0); glVertex2f(0, bh);
320 glVertex2f((bw+bwt)*0.5, bh*0.5); glVertex2f(-(bw+bwt)*0.5, bh*0.5);
321 glEnd();
322
324 glBegin(GL_LINE_LOOP);
325 glVertex2f(-bw, 0);
326 glVertex2f( bw, 0);
327 glVertex2f( bwt, bh);
328 glVertex2f(-bwt, bh);
329 glEnd();
331
332 glTranslatef(0, fSliderPosY, 0.5);
333
334 if (fShowSlider)
335 {
336 // event handler
337 if (rnrCtx.Selection())
338 {
339 glLoadName(2);
340 Float_t w = fButtonW*fMenuW*0.5f;
341 glBegin(GL_QUADS);
342 glVertex2f(-w, 0);
343 glVertex2f( w, 0);
344 glVertex2f( w, fSliderH);
345 glVertex2f(-w, fSliderH);
346 glEnd();
347 }
348
349 // slider axis
351 fAxisPainter->RefDir().Set(0, 1, 0);
352 fAxisPainter->RefTMOff(0).Set(1, 0, 0);
354 fPlaneAxis->SetRangeUser(0, maxVal);
355 fPlaneAxis->SetLimits(0, maxVal);
357 fPlaneAxis->SetTickLength(0.02*maxVal);
358 fPlaneAxis->SetLabelOffset(0.02*maxVal);
360
361 glPushMatrix();
362 glScalef(fSliderH/(maxVal), fSliderH/maxVal, 1.);
364 glPopMatrix();
365
366 // marker
367 TGLUtil::Color((fActiveID == 2) ? fActiveCol : 3);
369 glBegin(GL_POINTS);
370 glVertex3f(0, fSliderVal*fSliderH, -0.1);
371 glEnd();
372 }
373
374 glPopName();
375 glPopMatrix();
376 glPopAttrib();
377}
378
379/******************************************************************************/
381{
382 // Draw slider of calo 2D in mode TEveCalo:fValSize.
383
384 TGLRect &vp = rnrCtx.GetCamera()->RefViewport();
385
386 Double_t maxVal = fCalo->GetMaxVal();
387 Int_t maxe = TMath::CeilNint(TMath::Log10(maxVal+1)); // max round exponent
388 Double_t sqv = TMath::Power(10, maxe)+1; // starting max square value
390 Double_t cellX = fCellX*fc;
391 Double_t cellY = fCellY*fc;
392
393 Double_t scaleStepY = 0.1; // step is 10% of screen
394 Double_t scaleStepX = scaleStepY*vp.Height()/vp.Width(); // step is 10% of screen
395
396 Double_t frameOff = 0.01;
397
398 // define max starting exponent not to take more than scalStepY height
399 while(cellY > scaleStepY)
400 {
401 fc = TMath::Log10(TMath::Power(10, maxe-1)+1)/TMath::Log10(TMath::Power(10, maxe)+1);
402 maxe --;
403 cellX *= fc;
404 cellY *= fc;
405 }
406
407 sqv = TMath::Power(10, maxe)+1;
408 glPushMatrix();
409 glTranslatef(fScaleCoordX + 0.5*scaleStepX + frameOff, fScaleCoordY + 0.5*scaleStepY + frameOff, 0); // translate to lower left corner
410
411 glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT | GL_LINE_BIT | GL_POINT_BIT);
412 glEnable(GL_BLEND);
413 glDisable(GL_CULL_FACE);
414 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
415 glEnable(GL_POLYGON_OFFSET_FILL);
416 glPolygonOffset(0.1, 1);
417
418 glPushName(0);
419 glLoadName(1);
420
421 // draw cells
422 Color_t color = fScaleColor > -1 ? fScaleColor : rnrCtx.ColorSet().Markup().GetColorIndex();
424
425 Float_t pos, dx, dy;
426 glBegin(GL_QUADS);
427 Int_t ne = 3; // max number of columns
428 for (Int_t i=0; i < ne; ++i)
429 {
430 Float_t valFac = TMath::Log10(TMath::Power(10, maxe-i)+1)/TMath::Log10(sqv);
431 dx = 0.5* cellX * valFac;
432 dy = 0.5* cellY * valFac;
433 pos = i* scaleStepY;
434 glVertex2f( - dx, pos - dy);
435 glVertex2f( - dx, pos + dy);
436 glVertex2f( + dx, pos + dy);
437 glVertex2f( + dx, pos - dy);
438 }
439 glEnd();
440
441 // draw points in case square is below pixels
442 glBegin(GL_POINTS);
443 for (Int_t i=0; i < ne; ++i)
444 glVertex2f(0, i* scaleStepY);
445 glEnd();
446
447 // draw numbers
448 TGLFont fontB;
449 Int_t fsb = TMath::Max(TMath::Nint(vp.Height()*0.03), 12);
450 rnrCtx.RegisterFontNoScale(fsb, "arial", TGLFont::kPixmap, fontB);
451 TGLFont fontE;
452 Int_t fsE = TMath::Max(TMath::Nint(vp.Height()*0.01), 8);
453 rnrCtx.RegisterFontNoScale(fsE, "arial", TGLFont::kPixmap, fontE);
454
455 Float_t llx, lly, llz, urx, ury, urz;
456 fontB.BBox("10", llx, lly, llz, urx, ury, urz);
457 Float_t expX = urx/vp.Width();
458 Float_t expY = (ury-lly)*0.5/vp.Height();
459 Float_t expOff = 1;
460 fontB.PreRender();
461 fontE.PreRender();
462 glPushMatrix();
463 glTranslatef(0.5*scaleStepX, 0, 0.1);
464 for (Int_t i = 0; i < ne; ++i)
465 {
466 if (i == maxe)
467 {
468 fontB.Render("1", 0, i*scaleStepY, 0, TGLFont::kLeft, TGLFont::kCenterV);
469 }
470 else if ( i == (maxe -1))
471 {
472 fontB.Render("10", 0, i*scaleStepY, 0, TGLFont::kLeft, TGLFont::kCenterV);
473 }
474 else
475 {
476 fontB.Render("10", 0, i*scaleStepY, 0, TGLFont::kLeft, TGLFont::kCenterV);
477 fontB.BBox(Form("%d", maxe-i), llx, lly, llz, urx, ury, urz);
478 if (expOff > urx/vp.Width()) expOff = urx/vp.Width();
479 fontE.Render(Form("%d", maxe-i), expX , i*scaleStepY+expY, 0, TGLFont::kLeft, TGLFont::kCenterV);
480 }
481 }
482 glPopMatrix();
483 fontB.PostRender();
484 fontE.PostRender();
485 if (expOff < 1) expX += expOff;
486 glPopMatrix();
487
488 // draw frame
489 {
490 fScaleW = scaleStepX + expX+ frameOff*2;
491 fScaleH = scaleStepY * ne + frameOff*2;
493 Double_t x1 = x0 + fScaleW;
495 Double_t y1 = y0 + fScaleH;
496 Double_t zf = +0.2;
497
498 color = fFrameColor > -1 ? fFrameColor : rnrCtx.ColorSet().Markup().GetColorIndex();
500
501 glBegin(GL_LINE_LOOP);
502 glVertex3f(x0, y0, zf); glVertex3f(x1, y0, zf);
503 glVertex3f(x1, y1, zf); glVertex3f(x0, y1, zf);
504 glEnd();
505
507 glBegin(GL_QUADS);
508 glVertex2f(x0, y0); glVertex2f(x1, y0);
509 glVertex2f(x1, y1); glVertex2f(x0, y1);
510 glEnd();
511 }
512 glPopName();
513
514 glPopAttrib();
515} // end draw scales
516
517////////////////////////////////////////////////////////////////////////////////
518
520{
521 // Draw slider of calo 2D in mode TEveCalo:fValColor.
522
523 glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT | GL_LINE_BIT);
524 glEnable(GL_BLEND);
525 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
526 glEnable(GL_POLYGON_OFFSET_FILL);
527 glPolygonOffset(0.1, 1);
528
529 TGLRect& vp = rnrCtx.RefCamera().RefViewport();
530 Double_t maxVal = fCalo->GetMaxVal();
531 Int_t bn = 0;
532 Double_t bw = 0; // bin with first second order
533 Double_t bl = 0, bh = 0; // bin low, high first
534 THLimitsFinder::Optimize(0, maxVal, 10, bl, bh, bn, bw);
535 bn = TMath::CeilNint(maxVal/bw) + 1;
536
537 fScaleH = 0.25; // relative height of the scale
538 fScaleW = fScaleH*1.5/(bn*vp.Aspect());
539 Float_t h = 0.5 * bw ;
540 Float_t w = h * 1.5/ vp.Aspect();
541
542 glPushMatrix();
543 glTranslatef(fScaleCoordX + fScaleW*0.5, fScaleCoordY + fScaleH/bn*0.5, 0); // translate to lower left corner
544 glScalef(fScaleH/(bn*bw), fScaleH/(bn*bw), 1.);
545
546 glPushName(0);
547 glLoadName(1);
549 labVec.clear();
550 Float_t val = 0;
551 for (Int_t l= 0; l<bn; l++) {
552 labVec.push_back( TGLAxisPainter::Lab_t(val, val));
553 val += bw;
554 }
555
557 fAxisPainter->RefDir().Set(0, 1, 0);
558 Int_t fs = TMath::CeilNint(rnrCtx.GetCamera()->RefViewport().Height()*0.02);
559 fAxisPainter->SetLabelFont(rnrCtx, "arial", fs);
560 fAxisPainter->SetTextFormat(0, maxVal, bw);
562 TAttAxis att;
565
566 UChar_t c[4];
567 Float_t y;
568 Double_t zf = +0.2;
569 glBegin(GL_QUADS);
570 for (TGLAxisPainter::LabVec_t::iterator it = labVec.begin(); it != labVec.end(); ++it)
571 {
572 fCalo->GetPalette()->ColorFromValue((Int_t)((*it).first), c);
573 glColor4ub( c[0], c[1], c[2], c[3]);
574
575 y = (*it).second;
576 glVertex3f( -w, y - h, zf); glVertex3f( +w, y - h, zf);
577 glVertex3f( +w, y + h, zf); glVertex3f( -w, y + h, zf);
578 }
579 glEnd();
580
582 glBegin(GL_LINE_LOOP);
583 for (TGLAxisPainter::LabVec_t::iterator it = labVec.begin(); it != labVec.end(); ++it)
584 {
585 y = (*it).second;
586 glVertex3f( -w, y - h, zf); glVertex3f( +w, y - h, zf);
587 glVertex3f( +w, y + h, zf); glVertex3f( -w, y + h, zf);
588 }
589 glEnd();
590
591 glPopName();
592 glPopMatrix();
593 glPopAttrib();
594}
595
596////////////////////////////////////////////////////////////////////////////////
597
599{
600 // Draw calorimeter scale info and plane interface.
601
602 if ( fCalo == 0 || fCalo->GetData()->Empty()) return;
603
604 Float_t old_depth_range[2];
605 glGetFloatv(GL_DEPTH_RANGE, old_depth_range);
606 glDepthRange(0, 0.001);
607
608 glMatrixMode(GL_PROJECTION);
609 glPushMatrix();
610 glLoadIdentity();
611 if (rnrCtx.Selection())
612 {
613 TGLRect rect(*rnrCtx.GetPickRectangle());
614 rnrCtx.GetCamera()->WindowToViewport(rect);
615 gluPickMatrix(rect.X(), rect.Y(), rect.Width(), rect.Height(),
616 (Int_t*) rnrCtx.GetCamera()->RefViewport().CArr());
617 }
618 glMatrixMode(GL_MODELVIEW);
619 glPushMatrix();
620 glLoadIdentity();
621
622 glTranslatef(-1, -1, 0);
623 glScalef(2, 2, 1);
624
625
626 TGLCapabilitySwitch lights_off(GL_LIGHTING, kFALSE);
627 TGLCamera& cam = rnrCtx.RefCamera();
628 Bool_t drawOverlayAxis = kTRUE;
629
630 if (cam.IsOrthographic())
631 {
632 // in 2D need pixel cell dimension
633 // project lego eta-phi boundaries
635 TGLVertex3 p;
636 TGLVector3 res = cam.WorldDeltaToViewport(p, rng);
637
638 TEveCaloLegoGL* lgl = dynamic_cast<TEveCaloLegoGL*>(rnrCtx.RefViewer().FindLogicalInScenes(fCalo));
639 if (fShowScales && lgl)
640 {
641
642 // get smallest bin
643 Double_t sq = 1e4;
644 if (lgl->fBinStep == 1)
645 {
647 for ( TEveCaloData::vCellId_t::iterator i = fCalo->fCellList.begin(); i != fCalo->fCellList.end(); ++i)
648 {
649 fCalo->fData->GetCellData(*i, cellData);
650 if (sq > cellData.EtaDelta()) sq = cellData.EtaDelta();
651 if (sq > cellData.PhiDelta()) sq = cellData.PhiDelta();
652 }
653 }
654 else
655 {
656 TAxis* a;
657 Int_t nb;
658 a = fCalo->GetData()->GetEtaBins();
659 nb = a->GetNbins();
660 for (Int_t i=1 ; i<=nb; i++)
661 {
662 if (sq > a->GetBinWidth(i)) sq = a->GetBinWidth(i);
663 }
664
665 a = fCalo->GetData()->GetPhiBins();
666 nb = a->GetNbins();
667 for (Int_t i=1 ; i<=nb; i++)
668 {
669 if (sq > a->GetBinWidth(i)) sq = a->GetBinWidth(i);
670 }
671
672 sq *= lgl->fBinStep;
673 }
674 fCellX = (res.X()*sq)/(fCalo->GetEtaRng()*1.*cam.RefViewport().Width());
675 fCellY = (res.Y()*sq)/(fCalo->GetPhiRng()*1.*cam.RefViewport().Height());
676 // printf("bin width %f cells size %f %f\n", sq, fCellX, fCellY);
679 else if (fCalo->GetPalette())
680 RenderPaletteScales(rnrCtx);
681 }
682
683 // draw camera overlay if projected lego bbox to large
684 SetFrustum(cam);
685 if ( fCalo->GetEtaMin() > fFrustum[0] && fCalo->GetEtaMax() < fFrustum[2]
686 && fCalo->GetPhiMin() > fFrustum[1] && fCalo->GetPhiMax() < fFrustum[3])
687 drawOverlayAxis = kFALSE;
688 }
689
690 if (cam.IsPerspective() && fShowPlane)
691 {
692 RenderPlaneInterface(rnrCtx);
693 }
694
695 // draw info text on top right corner
696 if (fHeaderTxt.Length())
697 {
698 RenderHeader(rnrCtx);
699 }
700
701 glPopMatrix();
702 glMatrixMode(GL_PROJECTION);
703 glPopMatrix();
704 glMatrixMode(GL_MODELVIEW);
705
706 glDepthRange(old_depth_range[0], old_depth_range[1]);
707
708 if (drawOverlayAxis) TGLCameraOverlay::Render(rnrCtx);
709}
#define GL_QUADS
Definition: GL_glu.h:290
#define GL_LINES
Definition: GL_glu.h:284
#define GL_POINTS
Definition: GL_glu.h:283
#define GL_LINE_LOOP
Definition: GL_glu.h:285
@ kButtonRelease
Definition: GuiTypes.h:59
@ kButtonPress
Definition: GuiTypes.h:59
@ kMotionNotify
Definition: GuiTypes.h:60
@ kButton1
Definition: GuiTypes.h:213
#define c(i)
Definition: RSha256.hxx:101
#define h(i)
Definition: RSha256.hxx:106
static const double x1[5]
int Int_t
Definition: RtypesCore.h:43
unsigned char UChar_t
Definition: RtypesCore.h:36
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
char * Form(const char *fmt,...)
static struct mg_connection * fc(struct mg_context *ctx)
Definition: civetweb.c:3728
Manages histogram axis attributes.
Definition: TAttAxis.h:18
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 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
Class to manage histogram axis.
Definition: TAxis.h:30
virtual void SetLimits(Double_t xmin, Double_t xmax)
Definition: TAxis.h:154
virtual void SetRangeUser(Double_t ufirst, Double_t ulast)
Set the viewing range for the axis from ufirst to ulast (in user coordinates).
Definition: TAxis.cxx:939
Bool_t Empty() const
Definition: TEveCaloData.h:216
virtual void GetCellData(const CellId_t &id, CellData_t &data) const =0
virtual TAxis * GetEtaBins() const
Definition: TEveCaloData.h:218
virtual TAxis * GetPhiBins() const
Definition: TEveCaloData.h:221
OpenGL renderer class for TEveCaloLego.
GL-overlay control GUI for TEveCaloLego.
Bool_t fInDrag
last mouse position
void RenderPlaneInterface(TGLRnrCtx &rnrCtx)
Render menu for plane-value and the plane if marked.
virtual void Render(TGLRnrCtx &rnrCtx)
Display coordinates info of current frustum.
void RenderHeader(TGLRnrCtx &rnrCtx)
void SetScaleColorTransparency(Color_t colIdx, Char_t transp)
Set color and transparency of scales.
TEveCaloLegoOverlay()
Constructor.
void RenderPaletteScales(TGLRnrCtx &rnrCtx)
virtual void MouseLeave()
Mouse has left overlay area.
Bool_t SetSliderVal(Event_t *event, TGLRnrCtx &rnrCtx)
void SetScalePosition(Double_t x, Double_t y)
Set scale coordinates in range [0,1].
virtual Bool_t MouseEnter(TGLOvlSelectRecord &selRec)
Mouse has entered overlay area.
void RenderLogaritmicScales(TGLRnrCtx &rnrCtx)
virtual Bool_t Handle(TGLRnrCtx &rnrCtx, TGLOvlSelectRecord &selRec, Event_t *event)
Handle overlay event.
void SetFrameAttribs(Color_t frameCol, Char_t lineTransp, Char_t bgTransp)
Set frame attributes.
Color_t GetFontColor() const
Definition: TEveCalo.h:300
void SetHPlaneVal(Float_t s)
Definition: TEveCalo.h:343
TEveCaloData::vCellId_t fCellList
Definition: TEveCalo.h:264
E2DMode_e Get2DMode()
Definition: TEveCalo.h:328
void SetDrawHPlane(Bool_t s)
Definition: TEveCalo.h:340
Float_t GetEtaMin() const
Definition: TEveCalo.h:136
TEveRGBAPalette * GetPalette() const
Definition: TEveCalo.h:124
Float_t GetPhiRng() const
Definition: TEveCalo.h:146
Float_t GetMaxVal() const
Definition: TEveCalo.cxx:159
TEveCaloData * GetData() const
Definition: TEveCalo.h:86
Float_t GetEtaMax() const
Definition: TEveCalo.h:137
TEveCaloData * fData
Definition: TEveCalo.h:39
Float_t GetPhiMax() const
Definition: TEveCalo.h:145
Float_t GetEtaRng() const
Definition: TEveCalo.h:138
Float_t GetPhiMin() const
Definition: TEveCalo.h:144
const UChar_t * ColorFromValue(Int_t val) const
void RnrLabels() const
Render label reading prepared list ov value-pos pairs.
void SetLabelFont(TGLRnrCtx &rnrCtx, const char *fontName, Int_t pixelSize=64, Double_t font3DSize=-1)
Set label font derived from TAttAxis.
TGLVector3 & RefDir()
void SetLabelAlign(TGLFont::ETextAlignH_e, TGLFont::ETextAlignV_e)
Set label align.
std::vector< Lab_t > LabVec_t
LabVec_t & RefLabVec()
void SetTextFormat(Double_t min, Double_t max, Double_t binWidth)
Construct print format from given primary bin width.
void SetAttAxis(TAttAxis *a)
void SetLabelPixelFontSize(Int_t fs)
std::pair< Float_t, Float_t > Lab_t
TGLVector3 & RefTMOff(Int_t i)
void PaintAxis(TGLRnrCtx &ctx, TAxis *ax)
GL render TAxis.
A GL overlay element which displays camera furstum.
TGLAxisPainter * fAxisPainter
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.
TAttAxis * GetAttAxis()
Get axis attributes.
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
TGLVector3 WorldDeltaToViewport(const TGLVertex3 &worldRef, const TGLVector3 &worldDelta) const
Convert a 3D vector worldDelta (shift) about vertex worldRef to a viewport (screen) '3D' vector.
Definition: TGLCamera.cxx:426
void WindowToViewport(Int_t &, Int_t &y) const
Definition: TGLCamera.h:197
virtual Bool_t IsOrthographic() const
Definition: TGLCamera.h:117
TGLRect & RefViewport()
Definition: TGLCamera.h:127
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
virtual void PostRender() const
Reset GL state after FTFont rendering.
virtual void PreRender(Bool_t autoLight=kTRUE, Bool_t lightOn=kFALSE) const
Set-up GL state before FTFont rendering.
Selection record for overlay objects.
Viewport (pixel base) 2D rectangle class.
Definition: TGLUtil.h:421
Int_t Y() const
Definition: TGLUtil.h:447
const Int_t * CArr() const
Definition: TGLUtil.h:442
Int_t Height() const
Definition: TGLUtil.h:451
Int_t Width() const
Definition: TGLUtil.h:449
Int_t X() const
Definition: TGLUtil.h:445
Double_t Aspect() const
Definition: TGLUtil.h:499
The TGLRnrCtx class aggregates data for a given redering context as needed by various parts of the RO...
Definition: TGLRnrCtx.h:41
TGLRect * GetPickRectangle()
Return current pick rectangle.
Definition: TGLRnrCtx.cxx:249
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
TGLViewerBase & RefViewer()
Definition: TGLRnrCtx.h:155
TGLCamera * GetCamera()
Definition: TGLRnrCtx.h:156
Bool_t Selection() const
Definition: TGLRnrCtx.h:222
UInt_t GetItem(Int_t i) const
Int_t GetN() const
static void Color4f(Float_t r, Float_t g, Float_t b, Float_t a)
Wrapper for glColor4f.
Definition: TGLUtil.cxx:1790
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 PointSize()
Get the point-size, taking the global scaling into account.
Definition: TGLUtil.cxx:1930
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
3 component (x/y/z) vertex class.
Definition: TGLUtil.h:83
Double_t X() const
Definition: TGLUtil.h:118
void Set(Double_t x, Double_t y, Double_t z)
Definition: TGLUtil.h:209
Double_t Y() const
Definition: TGLUtil.h:120
TGLLogicalShape * FindLogicalInScenes(TObject *id)
Find logical-shape representing object id in the list of scenes.
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.
Ssiz_t Length() const
Definition: TString.h:405
const char * Data() const
Definition: TString.h:364
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
Int_t Nint(T x)
Round to nearest integer. Rounds half integers to the nearest even integer.
Definition: TMath.h:703
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:212
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Definition: TMath.h:725
Int_t CeilNint(Double_t x)
Definition: TMath.h:689
Double_t Log10(Double_t x)
Definition: TMath.h:754
EGEventType fType
Definition: GuiTypes.h:174
Int_t fY
Definition: GuiTypes.h:177
UInt_t fState
Definition: GuiTypes.h:180
Int_t fX
Definition: GuiTypes.h:177
UInt_t fCode
Definition: GuiTypes.h:179
Cell data inner structure.
Definition: TEveCaloData.h:115
Float_t PhiDelta() const
Definition: TEveCaloData.h:98
Float_t EtaDelta() const
Definition: TEveCaloData.h:93
auto * l
Definition: textangle.C:4
auto * a
Definition: textangle.C:12