Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TAxis3D.cxx
Go to the documentation of this file.
1// @(#)root/g3d:$Id$
2// Author: Valery Fine(fine@mail.cern.ch) 07/01/2000
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, 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 <cctype>
13#include <cassert>
14#include <iostream>
15
16#include "TMath.h"
17#include "TList.h"
18#include "TAxis3D.h"
19#include "TClass.h"
20#include "TPad.h"
21#include "TGaxis.h"
22#include "TView.h"
23#include "TVirtualX.h"
24#include "TBrowser.h"
25#include "TStyle.h"
26#include "strlcpy.h"
27
28/** \class TAxis3D
29\ingroup g3d
30
31The 3D axis painter class
32
33This class provide up to 3 axes to any 3D ROOT plot and "ZOOM" service.
34ExecuteEvent() method does provide zooming and moving a projection
353D object within TPad client area. With Zoom mode on the user can access
36TAxis3D context menu and set /change the attributes of axes all together
37or separately.
38
39To add the 3D rulers to any 3D view one has to create
40an instance of this class and Draw it.
41
42~~~ {.cpp}
43 TAxis3D rulers;
44 rulers.Draw();
45~~~
46
47One can use a static method to create ruler and attach it to the current gPad
48
49~~~ {.cpp}
50 TAxis3D::ToggleRulers(); // Brings the 3D axes up
51 TAxis3D::ToggleRulers(); // next calls remove the rulers from the TPad etc
52~~~
53
54To activate Zoomer one may call
55
56~~~ {.cpp}
57 TAxis3D::ToggleZoom();
58~~~
59
60each time one needs move or zoom the image. Then the user can:
61
62 - move:
63\image html g3d_axis3d_01.png
64 - zoom:
65\image html g3d_axis3d_02.png
66
67its 3D view with <left-mouse button> press / move.
68The "Zoom" deactivates itself just the user release the <left-mouse button>
69
70To change attributes of the rulers attached to the current Pad, one may
71query its pointer first:
72
73~~~ {.cpp}
74TAxis3D *axis = TAxis3D::GetPadAxis(); // Ask axis pointer
75if (axis) {
76 TAxis3D::ToggleRulers() // To pop axes down
77 axis->SetLabelColor(kBlue); // Paint the axes labels with blue color
78 axis->SetAxisColor(kRed); // Paint the axes itself with blue color
79 TAxis3D::ToggleRulers() // To pop axes up
80}
81~~~
82
83The attributes of the created axes are affected by the current style
84(see TStyle class ) and Set... methods of this class
85
86For example:
87~~~ {.cpp}
88 gStyle->SetAxisColor(kYellow,"X");
89 gStyle->SetAxisColor(kYellow,"Y");
90 gStyle->SetAxisColor(kYellow,"Z");
91
92 gStyle->SetLabelColor(kYellow,"X");
93 gStyle->SetLabelColor(kYellow,"Y");
94 gStyle->SetLabelColor(kYellow,"Z");
95
96 TAxis3D::ToggleRulers();
97 TAxis3D::ToggleRulers();
98~~~
99
100will draw all axes and labels with yellow color.
101*/
102
103const Char_t *TAxis3D::fgRulerName = "axis3druler";
105
106////////////////////////////////////////////////////////////////////////////////
107/// Normal constructor.
108
109TAxis3D::TAxis3D() : TNamed(TAxis3D::fgRulerName,"ruler")
110{
111 fSelected = 0;
114 InitSet();
115}
116
117////////////////////////////////////////////////////////////////////////////////
118/// Normal constructor.
119
120TAxis3D::TAxis3D(Option_t *) : TNamed(TAxis3D::fgRulerName,"ruler")
121{
122 fSelected = 0;
123 InitSet();
126}
127
128////////////////////////////////////////////////////////////////////////////////
129/// Copy constructor.
130
131TAxis3D::TAxis3D(const TAxis3D &axis) : TNamed(axis)
132{
133 ((TAxis3D&)axis).Copy(*this);
134}
135
136////////////////////////////////////////////////////////////////////////////////
137/// Copy axis3d
138
139void TAxis3D::Copy(TObject &obj) const
140{
141 TNamed::Copy(obj);
142 for (Int_t i=0;i<2;i++) fAxis[i].Copy(((TAxis3D&)obj).fAxis[i]);
143}
144
145////////////////////////////////////////////////////////////////////////////////
146/// Initialization.
147
149{
150 fAxis[0].SetName("xaxis");
151 fAxis[1].SetName("yaxis");
152 fAxis[2].SetName("zaxis");
153
154 fAxis[0].Set(1,0.,1.);
155 fAxis[1].Set(1,0.,1.);
156 fAxis[2].Set(1,0.,1.);
158}
159
160////////////////////////////////////////////////////////////////////////////////
161/// Add all 3 axes to the TBrowser
162
164{
165 for (Int_t i=0;i<3;i++) b->Add(&fAxis[i],fAxis[i].GetTitle());
166}
167
168////////////////////////////////////////////////////////////////////////////////
169/// Compute distance from point px,py to a line.
170
172{
173 Int_t dist = 9;
174 for (int i=0;i<3;i++) {
175 Int_t axDist = fAxis[i].DistancetoPrimitive(px,py);
176 if (dist > axDist) { dist = axDist; fSelected = &fAxis[i]; }
177 }
178 if (fZoomMode)
179 return 0;
180 else
181 return dist;
182}
183
184////////////////////////////////////////////////////////////////////////////////
185/// Execute action corresponding to one event.
186///
187/// This member function is called when an axis is clicked with the locator
188
190{
191 if (!gPad) return;
192
193 if (fSelected) fSelected->ExecuteEvent(event,px,py);
194
195 // Execute action corresponding to the mouse event
196
197 static Double_t x0, y0, x1, y1;
198
199 static Int_t pxold, pyold;
200 static Int_t px0, py0;
201 static Int_t linedrawn;
202
203 if (!fZoomMode) return;
204
205 // something to zoom ?
206
207 gPad->SetCursor(kCross);
208
209 switch (event) {
210
211 case kButton1Down:
212 gVirtualX->SetLineColor(-1);
213 gPad->TAttLine::Modify(); //Change line attributes only if necessary
214 ((TPad *)gPad)->AbsPixeltoXY(px,py,x0,y0);
215 px0 = px; py0 = py;
216 pxold = px; pyold = py;
217 linedrawn = 0;
218 break;
219
220 case kButton1Motion:
221 if (linedrawn) gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
222 pxold = px;
223 pyold = py;
224 linedrawn = 1;
225 gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
226 break;
227
228 case kButton1Up: {
229 Int_t i;
230 gPad->SetDoubleBuffer(1);
231 gVirtualX->SetDrawMode(TVirtualX::kCopy); // set drawing mode back to normal (copy) mode
232 TView *view = gPad->GetView();
233 if (!view) break; // no 3D view yet
234
235 Double_t min[3],max[3],viewCenter[3],viewCenterNDC[3];
236
237 view->GetRange(min,max);
238 for (i =0; i<3;i++) viewCenter[i] = (max[i]+min[i])/2;
239 view->WCtoNDC(viewCenter,viewCenterNDC);
240 // Define the center
241 Double_t center[3],pointNDC[3],size[3],oldSize[3];
242 ((TPad *)gPad)->AbsPixeltoXY(px,py,x1,y1);
243 pointNDC[0] = (x0+x1)/2; pointNDC[1] = (y0+y1)/2;
244 pointNDC[2] = viewCenterNDC[2];
245 view->NDCtoWC(pointNDC, center);
246
247 for (i =0; i<3;i++) oldSize[i] = size[i]= (max[i]-min[i])/2;
248
249 // If there was a small motion, move the center only, do not change a scale
250 if (TMath::Abs(px-px0)+TMath::Abs(py - py0) > 4 ) {
251 Double_t newEdge[3];
252 for (i =0; i<3;i++) size[i] = -1;
253
254 pointNDC[0] = x0; pointNDC[1] = y0;
255
256 view->NDCtoWC(pointNDC, newEdge);
257 for (i =0; i<3;i++) {
258 Double_t newSize = TMath::Abs(newEdge[i]-center[i]);
259 if ( newSize/oldSize[i] > 0.002)
260 size[i] = TMath::Max(size[i], newSize);
261 else
262 size[i] = oldSize[i];
263 }
264
265 pointNDC[0] = x1; pointNDC[1] = y1;
266
267 view->NDCtoWC(pointNDC, newEdge);
268 for (i =0; i<3;i++) {
269 Double_t newSize = TMath::Abs(newEdge[i]-center[i]);
270 if ( newSize/oldSize[i] > 0.002)
271 size[i] = TMath::Max(size[i], newSize);
272 else
273 size[i] = oldSize[i];
274 }
275#if 0
276 if (fZooms == kMAXZOOMS) fZoom = 0;
277 fZooms++;
278 memcpy(fZoomMin[fZooms],min,3*sizeof(Float_t));
279 memcpy(fZoomMax[fZooms],max,3*sizeof(Float_t));
280#endif
281 }
282 for (i =0; i<3;i++) {
283 max[i] = center[i] + size[i];
284 min[i] = center[i] - size[i];
285 }
286 view->SetRange(min,max);
287
289 gPad->Modified(kTRUE);
290 gPad->Update();
291 break;
292 }
293 default: break;
294 }
295}
296
297////////////////////////////////////////////////////////////////////////////////
298/// Dummy method
299/// returns the const char * to "axis3d"
300
302{
303 return (char*)"axis3d";
304}
305
306////////////////////////////////////////////////////////////////////////////////
307/// Paint axis over 3D view on the TPad
308
310{
311 TGaxis axis;
312 PaintAxis(&axis, 90);
313}
314
315////////////////////////////////////////////////////////////////////////////////
316/// Draw the axis for TView object.
317///
318/// The original idea belongs:
319///
320/// void THistPainter::PaintLegoAxis(TGaxis *axis, Double_t ang)
321
323{
324 static Double_t epsil = 0.001;
325
326 Double_t cosa, sina;
327 Double_t bmin, bmax;
328 Double_t r[24] /* was [3][8] */;
329 Int_t ndiv, i;
330 Double_t x1[3], x2[3], y1[3], y2[3], z1[3], z2[3], av[24] /* was [3][8] */;
331 char chopax[10];
332 Int_t ix1, ix2, iy1, iy2, iz1, iz2;
333 Double_t rad;
334
335 TView *view = gPad->GetView();
336 if (!view) {
337 Error("PaintAxis", "no TView in current pad");
338 return;
339 }
340
341 rad = TMath::ATan(1.) * 4. / 180.;
342 cosa = TMath::Cos(ang*rad);
343 sina = TMath::Sin(ang*rad);
344
345 view->AxisVertex(ang, av, ix1, ix2, iy1, iy2, iz1, iz2);
346 for (i = 1; i <= 8; ++i) {
347 r[i*3 - 3] = av[i*3 - 3] + av[i*3 - 2]*cosa;
348 r[i*3 - 2] = av[i*3 - 2]*sina;
349 r[i*3 - 1] = av[i*3 - 1];
350 }
351
352 view->WCtoNDC(&r[ix1*3 - 3], x1);
353 view->WCtoNDC(&r[ix2*3 - 3], x2);
354 view->WCtoNDC(&r[iy1*3 - 3], y1);
355 view->WCtoNDC(&r[iy2*3 - 3], y2);
356 view->WCtoNDC(&r[iz1*3 - 3], z1);
357 view->WCtoNDC(&r[iz2*3 - 3], z2);
358
359 view->SetAxisNDC(x1, x2, y1, y2, z1, z2);
360
361 Double_t *rmin = view->GetRmin();
362 Double_t *rmax = view->GetRmax();
363
364 axis->SetLineWidth(1);
365
366 for (i=0;i<3;i++) {
367
368 // X axis drawing
369 Double_t ax[2], ay[2];
370 Bool_t logAx = kFALSE;
371 memset(chopax,0,sizeof(chopax));
372 switch (i) {
373 case 0 :
374 ax[0] = x1[0]; ax[1] = x2[0];
375 ay[0] = x1[1]; ay[1] = x2[1];
376 logAx = gPad->GetLogx();
377 break;
378 case 1 :
379 if (TMath::Abs(y1[0] - y2[0]) < epsil) y2[0] = y1[0];
380 ax[0] = y1[0]; ax[1] = y2[0];
381 ay[0] = y1[1]; ay[1] = y2[1];
382 logAx = gPad->GetLogy();
383 break;
384 case 2 :
385 ax[0] = z1[0]; ax[1] = z2[0];
386 ay[0] = z1[1]; ay[1] = z2[1];
387 strlcpy(chopax, "SDH+=",10);
388 logAx = gPad->GetLogz();
389 break;
390 default:
391 assert(0);
392 continue;
393 };
394
395 // If the axis is too short - skip it
396 if ( ( TMath::Abs(ax[0] - ax[1]) + TMath::Abs(ay[0] - ay[1])) < epsil ) continue;
397
398 if (i != 2 ) {
399 if (ax[0] > ax[1]) strlcpy(chopax, "SDHV=+",10);
400 else strlcpy(chopax, "SDHV=-",10);
401 }
402
403 if (i==1 && (TMath::Abs(z1[0] - z2[0]) + TMath::Abs(z1[1] - z2[1])) < epsil)
404 strlcpy(chopax, "SDH+=",10);
405
406 // Initialize the axis options
407 if (logAx) {
408 strlcat(chopax,"G",10);
409 bmin = TMath::Power(10, rmin[i]);
410 bmax = TMath::Power(10, rmax[i]);
411 } else {
412 bmin = rmin[i];
413 bmax = rmax[i];
414 }
415
416 axis->SetLineColor( fAxis[i].GetAxisColor());
417 axis->SetTextFont( fAxis[i].GetTitleFont());
418 axis->SetTextColor( fAxis[i].GetTitleColor());
419 axis->SetTickSize( fAxis[i].GetTickLength());
420 axis->SetLabelColor( fAxis[i].GetLabelColor());
421 axis->SetLabelFont( fAxis[i].GetLabelFont());
423 axis->SetLabelSize( fAxis[i].GetLabelSize());
424 axis->SetTitle( fAxis[i].GetTitle());
426 axis->SetTitleSize( fAxis[i].GetTitleSize());
427 enum { kCenterTitle = BIT(12) }; // to be removed with the last version of ROOT
428 axis->SetBit(kCenterTitle, fAxis[i].TestBit(kCenterTitle));
429
430 //*-*- Initialize the number of divisions. If the
431 //*-*- number of divisions is negative, option 'N' is required.
432 ndiv = fAxis[i].GetNdivisions();
433 if (ndiv < 0) {
434 ndiv = -ndiv;
435 chopax[6] = 'N';
436 }
437
438 // Option time display is required ?
439 if (fAxis[i].GetTimeDisplay()) {
440 strlcat(chopax,"t",10);
441 if (strlen(fAxis[i].GetTimeFormatOnly()) == 0) {
442 axis->SetTimeFormat(fAxis[i].ChooseTimeFormat(bmax-bmin));
443 } else {
444 axis->SetTimeFormat(fAxis[i].GetTimeFormat());
445 }
446 }
447 axis->SetOption(chopax);
448 axis->PaintAxis(ax[0], ay[0], ax[1], ay[1], bmin, bmax, ndiv, chopax);
449 }
450}
451
452////////////////////////////////////////////////////////////////////////////////
453/// Convert "screen pixel" coordinates to some center of 3D WC coordinate
454/// if view and gPad present
455
457{
458 Double_t *thisPoint = 0;
459 if (!view && gPad) view = gPad->GetView();
460 if (view) {
461 Double_t x[3] = {px,py,0.5}; // ((TPad *)thisPad)->AbsPixeltoXY(px,py,x[0],x[1]);
462 Double_t min[3], max[3];
463 view->GetRange(min,max);
464 Int_t i;
465 for (i =0; i<3;i++) min[i] = (max[i]+min[i])/2;
466 view->WCtoNDC(min,max);
467 min[0] = x[0]; min[1] = x[1];
468 min[2] = max[2];
469 view->NDCtoWC(min, x);
470 for (i=0;i<3;i++) point3D[i] = x[i];
471 thisPoint = point3D;
472 }
473 return thisPoint;
474}
475
476////////////////////////////////////////////////////////////////////////////////
477/// Save primitive as a C++ statement(s) on output stream out
478
479void TAxis3D::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
480{
481 fAxis[0].SaveAttributes(out,GetName(),"->GetXaxis()");
482 fAxis[1].SaveAttributes(out,GetName(),"->GetYaxis()");
483 fAxis[2].SaveAttributes(out,GetName(),"->GetZaxis()");
484}
485
486////////////////////////////////////////////////////////////////////////////////
487/// Replace current attributes by current style.
488
490{
491 if (gStyle->IsReading()) {
492 fAxis[0].ResetAttAxis("X");
493 fAxis[1].ResetAttAxis("Y");
494 fAxis[2].ResetAttAxis("Z");
495
496 fAxis[0].SetTitle("x");
500 } else {
509 gStyle->SetTitleSize (fAxis[0].GetTitleSize(), "x");
510 gStyle->SetTitleColor (fAxis[0].GetTitleColor(), "x");
511 gStyle->SetTitleFont (fAxis[0].GetTitleFont(), "x");
512
521 gStyle->SetTitleSize (fAxis[1].GetTitleSize(), "y");
522 gStyle->SetTitleColor (fAxis[1].GetTitleColor(), "y");
523 gStyle->SetTitleFont (fAxis[1].GetTitleFont(), "y");
524
533 gStyle->SetTitleSize (fAxis[2].GetTitleSize(), "z");
534 gStyle->SetTitleColor (fAxis[2].GetTitleColor(), "z");
535 gStyle->SetTitleFont (fAxis[2].GetTitleFont(), "z");
536 }
537}
538
539////////////////////////////////////////////////////////////////////////////////
540/// Return the axis index by its name
541
543{
544 char achoice = toupper(axis[0]);
545 if (achoice == 'X') return 0;
546 if (achoice == 'Y') return 1;
547 if (achoice == 'Z') return 2;
548 return -1;
549}
550
551////////////////////////////////////////////////////////////////////////////////
552/// Get number of divisions.
553
555{
556 Int_t ax = AxisChoice(axis);
557 if (ax < 0) return 0;
558 return fAxis[ax].GetNdivisions();
559}
560
561////////////////////////////////////////////////////////////////////////////////
562/// Get axis color.
563
565{
566 Int_t ax = AxisChoice(axis);
567 if (ax < 0) return 0;
568 return fAxis[ax].GetAxisColor();
569}
570
571////////////////////////////////////////////////////////////////////////////////
572/// Get label color.
573
575{
576 Int_t ax = AxisChoice(axis);
577 if (ax < 0) return 0;
578 return fAxis[ax].GetLabelColor();
579}
580
581////////////////////////////////////////////////////////////////////////////////
582/// Get label font.
583
585{
586 Int_t ax = AxisChoice(axis);
587 if (ax < 0) return 0;
588 return fAxis[ax].GetLabelFont();
589}
590
591////////////////////////////////////////////////////////////////////////////////
592/// Get label offset.
593
595{
596 Int_t ax = AxisChoice(axis);
597 if (ax < 0) return 0;
598 return fAxis[ax].GetLabelOffset();
599}
600
601////////////////////////////////////////////////////////////////////////////////
602/// Get label size.
603
605{
606 Int_t ax = AxisChoice(axis);
607 if (ax < 0) return 0;
608 return fAxis[ax].GetLabelSize();
609}
610
611////////////////////////////////////////////////////////////////////////////////
612/// Get tick mark length.
613
615{
616 Int_t ax = AxisChoice(axis);
617 if (ax < 0) return 0;
618 return fAxis[ax].GetTickLength();
619}
620
621////////////////////////////////////////////////////////////////////////////////
622/// Get title offset.
623
625{
626 Int_t ax = AxisChoice(axis);
627 if (ax < 0) return 0;
628 return fAxis[ax].GetTitleOffset();
629}
630
631////////////////////////////////////////////////////////////////////////////////
632
633#define AXISCHOICE \
634 Int_t i = AxisChoice(axis); \
635 Int_t nax = 1; \
636 if (i == -1) { i = 0; nax = 3;}\
637 for (Int_t ax=i;ax<nax+i;ax++)
638
639////////////////////////////////////////////////////////////////////////////////
640/// Set number of divisions.
641
643{
645}
646
647////////////////////////////////////////////////////////////////////////////////
648/// Set axis color.
649
651{
652 AXISCHOICE {fAxis[ax].SetAxisColor(color);}
653}
654
655////////////////////////////////////////////////////////////////////////////////
656/// Set axis range.
657
659{
660 Int_t ax = AxisChoice(axis);
661 if (ax < 0) return;
662 TAxis *theAxis = &fAxis[ax];
663 Int_t bin1 = theAxis->FindBin(xmin);
664 Int_t bin2 = theAxis->FindBin(xmax);
665 theAxis->SetRange(bin1, bin2);
666}
667
668////////////////////////////////////////////////////////////////////////////////
669/// Set label color.
670
672{
673 AXISCHOICE { fAxis[ax].SetLabelColor(color); }
674}
675
676////////////////////////////////////////////////////////////////////////////////
677/// Set label font.
678
680{
681 AXISCHOICE { fAxis[ax].SetLabelFont(font); }
682}
683
684////////////////////////////////////////////////////////////////////////////////
685/// Set label offset.
686
688{
689 AXISCHOICE { fAxis[ax].SetLabelOffset(offset); }
690}
691
692////////////////////////////////////////////////////////////////////////////////
693/// Set label size.
694
696{
697 AXISCHOICE { fAxis[ax].SetLabelSize(size); }
698}
699
700////////////////////////////////////////////////////////////////////////////////
701/// Set tick mark length.
702
704{
705 AXISCHOICE { fAxis[ax].SetTickLength(length); }
706}
707
708////////////////////////////////////////////////////////////////////////////////
709/// Set title offset.
710
712{
713 AXISCHOICE { fAxis[ax].SetTitleOffset(offset); }
714}
715#undef AXISCHOICE
716
717////////////////////////////////////////////////////////////////////////////////
718/// Returns the "pad" Axis3D object pointer if any.
719
721{
722 TObject *obj = 0;
723 TVirtualPad *thisPad=pad;
724 if (!thisPad) thisPad = gPad;
725 if (thisPad) {
726 // Find axis in the current thisPad
727 obj = thisPad->FindObject(TAxis3D::fgRulerName);
728 if (!(obj && obj->InheritsFrom(Class()->GetName()))) obj = 0;
729 }
730 return (TAxis3D *)obj;
731}
732
733////////////////////////////////////////////////////////////////////////////////
734/// Turn ON / OFF the "Ruler", TAxis3D object attached
735/// to the current pad
736
738{
739 TAxis3D *ax = 0;
740 TVirtualPad *thisPad=pad;
741 if (!thisPad) thisPad = gPad;
742 if (thisPad && thisPad->GetView() ) {
743 TAxis3D *a = GetPadAxis(pad);
744 if (a) delete a;
745 else {
746 ax = new TAxis3D;
747 ax->SetBit(kCanDelete);
748 ax->Draw();
749 }
750 thisPad->Modified();
751 thisPad->Update();
752 }
753 return ax;
754}
755
756////////////////////////////////////////////////////////////////////////////////
757/// Turn ON / OFF the "Ruler" and "zoom mode" of the TAxis3D object attached
758/// to the current pad (if pad = 0; gPad is used "by default")
759///
760/// User is given a chance to either:
761/// 1. move the center of the 3D scene at the cursor position
762/// 2. zoom view with mouse "drugging" the bounder rectangle with "left" mouse
763/// 3. Change the axis attributes via TContextMenu with "right mouse button click"
764
766{
767 TAxis3D *ax = 0;
768 TVirtualPad *thisPad=pad;
769 if (!thisPad) thisPad = gPad;
770 if (thisPad && thisPad->GetView()) {
771 // Find axis in the current thisPad
772 TList *l = thisPad->GetListOfPrimitives();
774 if (o && o->InheritsFrom(Class()->GetName())) { // Find axis
775 if (o != l->Last()) { // make sure the TAxis3D is the last object of the Pad.
776 l->Remove(o);
777 l->AddLast(o);
778 }
779 ax = (TAxis3D *)o;
780 } else { // There is no
781 ax = new TAxis3D;
782 ax->SetBit(kCanDelete);
783 ax->Draw();
784 }
785 ax->SwitchZoom();
786 }
787 return ax;
788}
@ kButton1Motion
Definition Buttons.h:20
@ kButton1Up
Definition Buttons.h:19
@ kButton1Down
Definition Buttons.h:17
void Class()
Definition Class.C:29
@ kCross
Definition GuiTypes.h:374
ROOT::R::TRInterface & r
Definition Object.C:4
#define b(i)
Definition RSha256.hxx:100
#define a(i)
Definition RSha256.hxx:99
static const double x2[5]
static const double x1[5]
char Char_t
Definition RtypesCore.h:37
const Bool_t kFALSE
Definition RtypesCore.h:92
double Double_t
Definition RtypesCore.h:59
short Color_t
Definition RtypesCore.h:83
short Style_t
Definition RtypesCore.h:80
float Float_t
Definition RtypesCore.h:57
const Bool_t kTRUE
Definition RtypesCore.h:91
const char Option_t
Definition RtypesCore.h:66
#define BIT(n)
Definition Rtypes.h:85
#define ClassImp(name)
Definition Rtypes.h:364
@ kRed
Definition Rtypes.h:66
@ kGreen
Definition Rtypes.h:66
@ kBlue
Definition Rtypes.h:66
#define AXISCHOICE
Definition TAxis3D.cxx:633
float xmin
float xmax
R__EXTERN TStyle * gStyle
Definition TStyle.h:412
#define gPad
#define gVirtualX
Definition TVirtualX.h:338
virtual Color_t GetLabelColor() const
Definition TAttAxis.h:38
virtual Int_t GetNdivisions() const
Definition TAttAxis.h:36
virtual Color_t GetAxisColor() const
Definition TAttAxis.h:37
virtual void SetTitleOffset(Float_t offset=1)
Set distance between the axis and the axis title.
Definition TAttAxis.cxx:293
virtual Float_t GetLabelOffset() const
Definition TAttAxis.h:40
virtual void SetAxisColor(Color_t color=1, Float_t alpha=1.)
Set color of the line axis and tick marks.
Definition TAttAxis.cxx:162
virtual void SetLabelSize(Float_t size=0.04)
Set size of axis labels.
Definition TAttAxis.cxx:203
virtual Style_t GetLabelFont() const
Definition TAttAxis.h:39
virtual void SetLabelOffset(Float_t offset=0.005)
Set distance between the axis and the labels.
Definition TAttAxis.cxx:192
virtual void SetLabelFont(Style_t font=62)
Set labels' font.
Definition TAttAxis.cxx:182
virtual Float_t GetLabelSize() const
Definition TAttAxis.h:41
virtual Float_t GetTickLength() const
Definition TAttAxis.h:45
virtual void ResetAttAxis(Option_t *option="")
Reset axis attributes.
Definition TAttAxis.cxx:78
virtual Float_t GetTitleOffset() const
Definition TAttAxis.h:43
virtual void SetTickLength(Float_t length=0.03)
Set tick mark length.
Definition TAttAxis.cxx:279
virtual void SetNdivisions(Int_t n=510, Bool_t optim=kTRUE)
Set the number of divisions for this axis.
Definition TAttAxis.cxx:228
virtual void SetLabelColor(Color_t color=1, Float_t alpha=1.)
Set color of labels.
Definition TAttAxis.cxx:172
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
Definition TAttLine.h:43
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition TAttLine.h:40
virtual void SetTextColor(Color_t tcolor=1)
Set the text color.
Definition TAttText.h:43
virtual void SetTextFont(Font_t tfont=62)
Set the text font.
Definition TAttText.h:45
The 3D axis painter class.
Definition TAxis3D.h:31
virtual Float_t GetLabelSize(Option_t *axis="X") const
Get label size.
Definition TAxis3D.cxx:604
Bool_t SwitchZoom()
Definition TAxis3D.h:113
virtual void SetNdivisions(Int_t n=510, Option_t *axis="*")
Set number of divisions.
Definition TAxis3D.cxx:642
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py)
Execute action corresponding to one event.
Definition TAxis3D.cxx:189
virtual void Paint(Option_t *option="")
Paint axis over 3D view on the TPad.
Definition TAxis3D.cxx:309
static TAxis3D * ToggleZoom(TVirtualPad *pad=0)
Turn ON / OFF the "Ruler" and "zoom mode" of the TAxis3D object attached to the current pad (if pad =...
Definition TAxis3D.cxx:765
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
Compute distance from point px,py to a line.
Definition TAxis3D.cxx:171
void PaintAxis(TGaxis *axis, Float_t ang)
Draw the axis for TView object.
Definition TAxis3D.cxx:322
virtual void SetLabelOffset(Float_t offset=0.005, Option_t *axis="*")
Set label offset.
Definition TAxis3D.cxx:687
virtual void SetLabelFont(Style_t font=62, Option_t *axis="*")
Set label font.
Definition TAxis3D.cxx:679
static Double_t * PixeltoXYZ(Double_t px, Double_t py, Double_t *point3D, TView *view=0)
Convert "screen pixel" coordinates to some center of 3D WC coordinate if view and gPad present.
Definition TAxis3D.cxx:456
TAxis fAxis[3]
Definition TAxis3D.h:38
virtual Style_t GetLabelFont(Option_t *axis="X") const
Get label font.
Definition TAxis3D.cxx:584
static TAxis3D * GetPadAxis(TVirtualPad *pad=0)
Returns the "pad" Axis3D object pointer if any.
Definition TAxis3D.cxx:720
virtual Float_t GetLabelOffset(Option_t *axis="X") const
Get label offset.
Definition TAxis3D.cxx:594
virtual void SetAxisRange(Double_t xmin, Double_t xmax, Option_t *axis="*")
Set axis range.
Definition TAxis3D.cxx:658
virtual Float_t GetTickLength(Option_t *axis="X") const
Get tick mark length.
Definition TAxis3D.cxx:614
virtual void SetLabelSize(Float_t size=0.02, Option_t *axis="*")
Set label size.
Definition TAxis3D.cxx:695
Int_t AxisChoice(Option_t *axis) const
Return the axis index by its name.
Definition TAxis3D.cxx:542
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save primitive as a C++ statement(s) on output stream out.
Definition TAxis3D.cxx:479
virtual Color_t GetAxisColor(Option_t *axis="X") const
Get axis color.
Definition TAxis3D.cxx:564
virtual void SetAxisColor(Color_t color=1, Option_t *axis="*")
Set axis color.
Definition TAxis3D.cxx:650
virtual Color_t GetLabelColor(Option_t *axis="X") const
Get label color.
Definition TAxis3D.cxx:574
virtual void Browse(TBrowser *b)
Add all 3 axes to the TBrowser.
Definition TAxis3D.cxx:163
Bool_t fZoomMode
The selected axis to play with.
Definition TAxis3D.h:42
virtual Float_t GetTitleOffset(Option_t *axis="X") const
Get title offset.
Definition TAxis3D.cxx:624
void InitSet()
Initialization.
Definition TAxis3D.cxx:148
void UseCurrentStyle()
Replace current attributes by current style.
Definition TAxis3D.cxx:489
virtual Int_t GetNdivisions(Option_t *axis="X") const
Get number of divisions.
Definition TAxis3D.cxx:554
static const char * fgRulerName
Definition TAxis3D.h:40
virtual void SetTickLength(Float_t length=0.02, Option_t *axis="*")
Set tick mark length.
Definition TAxis3D.cxx:703
static TAxis3D * ToggleRulers(TVirtualPad *pad=0)
Turn ON / OFF the "Ruler", TAxis3D object attached to the current pad.
Definition TAxis3D.cxx:737
virtual void Copy(TObject &hnew) const
Copy axis3d.
Definition TAxis3D.cxx:139
virtual char * GetObjectInfo(Int_t px, Int_t py) const
Dummy method returns the const char * to "axis3d".
Definition TAxis3D.cxx:301
virtual void SetLabelColor(Color_t color=1, Option_t *axis="*")
Set label color.
Definition TAxis3D.cxx:671
Bool_t fStickyZoom
Definition TAxis3D.h:43
TAxis3D()
Normal constructor.
Definition TAxis3D.cxx:109
virtual void SetTitleOffset(Float_t offset=1, Option_t *axis="*")
Set title offset.
Definition TAxis3D.cxx:711
TAxis * fSelected
Definition TAxis3D.h:41
Class to manage histogram axis.
Definition TAxis.h:30
virtual void SaveAttributes(std::ostream &out, const char *name, const char *subname)
Save axis attributes as C++ statement(s) on output stream out.
Definition TAxis.cxx:661
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py)
Execute action corresponding to one event.
Definition TAxis.cxx:281
virtual Int_t FindBin(Double_t x)
Find bin number corresponding to abscissa x.
Definition TAxis.cxx:293
virtual void Set(Int_t nbins, Double_t xmin, Double_t xmax)
Initialize axis with fix bins.
Definition TAxis.cxx:731
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
Compute distance from point px,py to an axis.
Definition TAxis.cxx:265
const char * GetTitle() const
Returns title of object.
Definition TAxis.h:129
virtual void SetRange(Int_t first=0, Int_t last=0)
Set the viewing range for the axis using bin numbers.
Definition TAxis.cxx:920
Using a TBrowser one can browse all ROOT objects.
Definition TBrowser.h:37
The axis painter class.
Definition TGaxis.h:23
void SetTimeFormat(const char *tformat)
Change the format used for time plotting.
Definition TGaxis.cxx:2734
virtual void PaintAxis(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax, Double_t &wmin, Double_t &wmax, Int_t &ndiv, Option_t *chopt="", Double_t gridlength=0, Bool_t drawGridOnly=kFALSE)
Control function to draw an axis.
Definition TGaxis.cxx:954
void SetTitleOffset(Float_t titleoffset=1)
Definition TGaxis.h:124
void SetLabelFont(Int_t labelfont)
Definition TGaxis.h:105
void SetTitleSize(Float_t titlesize)
Definition TGaxis.h:125
virtual void SetTitle(const char *title="")
Change the title of the axis.
Definition TGaxis.cxx:2707
void SetLabelOffset(Float_t labeloffset)
Definition TGaxis.h:106
void SetLabelColor(Int_t labelcolor)
Definition TGaxis.h:104
void SetTickSize(Float_t ticksize)
Definition TGaxis.h:118
void SetLabelSize(Float_t labelsize)
Definition TGaxis.h:107
void SetOption(Option_t *option="")
To set axis options.
Definition TGaxis.cxx:2699
A doubly linked list.
Definition TList.h:44
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
virtual void Copy(TObject &named) const
Copy this to obj.
Definition TNamed.cxx:94
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:164
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition TNamed.cxx:140
virtual const char * GetTitle() const
Returns title of object.
Definition TNamed.h:48
virtual const char * GetName() const
Returns name of object.
Definition TNamed.h:47
Mother of all ROOT objects.
Definition TObject.h:37
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition TObject.h:187
virtual TObject * FindObject(const char *name) const
Must be redefined in derived classes.
Definition TObject.cxx:323
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:696
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition TObject.cxx:445
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:893
virtual void Draw(Option_t *option="")
Default Draw method for all objects.
Definition TObject.cxx:197
@ kCanDelete
if object in a list can be deleted
Definition TObject.h:58
The most important graphics class in the ROOT system.
Definition TPad.h:26
void SetAxisColor(Color_t color=1, Option_t *axis="X")
Set color to draw the axis line and tick marks.
Definition TStyle.cxx:1271
Bool_t IsReading() const
Definition TStyle.h:282
void SetTitleFont(Style_t font=62, Option_t *axis="X")
Definition TStyle.cxx:1725
void SetTitleOffset(Float_t offset=1, Option_t *axis="X")
Specify a parameter offset to control the distance between the axis and the axis title.
Definition TStyle.cxx:1748
void SetTitleColor(Color_t color=1, Option_t *axis="X")
Definition TStyle.cxx:1704
void SetLabelFont(Style_t font=62, Option_t *axis="X")
Set font number used to draw axis labels.
Definition TStyle.cxx:1361
void SetLabelOffset(Float_t offset=0.005, Option_t *axis="X")
Set offset between axis and axis labels.
Definition TStyle.cxx:1377
void SetTitleSize(Float_t size=0.02, Option_t *axis="X")
Definition TStyle.cxx:1767
void SetTickLength(Float_t length=0.03, Option_t *axis="X")
Set the tick marks length for an axis.
Definition TStyle.cxx:1685
void SetNdivisions(Int_t n=510, Option_t *axis="X")
Set the number of divisions to draw an axis.
Definition TStyle.cxx:1257
void SetLabelColor(Color_t color=1, Option_t *axis="X")
Set axis labels color.
Definition TStyle.cxx:1341
void SetLabelSize(Float_t size=0.04, Option_t *axis="X")
Set size of axis labels.
Definition TStyle.cxx:1392
See TView3D.
Definition TView.h:25
virtual Double_t * GetRmax()=0
virtual void SetAxisNDC(const Double_t *x1, const Double_t *x2, const Double_t *y1, const Double_t *y2, const Double_t *z1, const Double_t *z2)=0
virtual Double_t * GetRmin()=0
virtual void WCtoNDC(const Float_t *pw, Float_t *pn)=0
virtual void NDCtoWC(const Float_t *pn, Float_t *pw)=0
virtual void GetRange(Float_t *min, Float_t *max)=0
virtual void SetRange(const Double_t *min, const Double_t *max)=0
virtual void AxisVertex(Double_t ang, Double_t *av, Int_t &ix1, Int_t &ix2, Int_t &iy1, Int_t &iy2, Int_t &iz1, Int_t &iz2)=0
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition TVirtualPad.h:51
virtual void Modified(Bool_t flag=1)=0
virtual TList * GetListOfPrimitives() const =0
virtual void Update()=0
virtual TView * GetView() const =0
Double_t x[n]
Definition legend1.C:17
const Int_t n
Definition legend1.C:16
Short_t Max(Short_t a, Short_t b)
Definition TMathBase.h:212
Double_t ATan(Double_t)
Definition TMath.h:675
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Definition TMath.h:735
Double_t Cos(Double_t)
Definition TMath.h:643
Double_t Sin(Double_t)
Definition TMath.h:639
Short_t Abs(Short_t d)
Definition TMathBase.h:120
auto * l
Definition textangle.C:4