Logo ROOT  
Reference Guide
TMarker3DBox.cxx
Go to the documentation of this file.
1// @(#)root/g3d:$Id$
2// Author: Rene Brun , Olivier Couet 31/10/97
3
4/*************************************************************************
5 * Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#include <iostream>
13#include "TROOT.h"
14#include "TBuffer.h"
15#include "TView.h"
16#include "TMarker3DBox.h"
17#include "TVirtualPad.h"
18#include "TH1.h"
19#include "TBuffer3D.h"
20#include "TBuffer3DTypes.h"
21#include "TVirtualViewer3D.h"
22#include "TGeometry.h"
23#include "TMath.h"
24
25#include <cassert>
26
28
29/** \class TMarker3DBox
30\ingroup g3d
31A special 3-D marker designed for event display.
32
33It has the following parameters:
34 - fX: X coordinate of the center of the box
35 - fY: Y coordinate of the center of the box
36 - fZ: Z coordinate of the center of the box
37 - fDx: half length in X
38 - fDy: half length in Y
39 - fDz: half length in Z
40 - fTheta: Angle of box z axis with respect to main Z axis
41 - fPhi: Angle of box x axis with respect to main Xaxis
42 - fRefObject: A reference to an object
43*/
44
45////////////////////////////////////////////////////////////////////////////////
46/// Marker3DBox default constructor
47
49{
50 fRefObject = 0;
51 fDx = 1;
52 fDy = 1;
53 fDz = 1;
54 fX = 0;
55 fY = 0;
56 fZ = 0;
57 fTheta = 0;
58 fPhi = 0;
60}
61
62////////////////////////////////////////////////////////////////////////////////
63/// Marker3DBox normal constructor
64
66 Float_t dx, Float_t dy, Float_t dz,
67 Float_t theta, Float_t phi)
68 :TAttLine(1,1,1), TAttFill(1,0)
69{
70 fDx = dx;
71 fDy = dy;
72 fDz = dz;
73 fX = x;
74 fY = y;
75 fZ = z;
76 fTheta = theta;
77 fPhi = phi;
78 fRefObject = 0;
80}
81
82////////////////////////////////////////////////////////////////////////////////
83/// copy constructor
84
86 TObject(m3d),
87 TAttLine(m3d),
88 TAttFill(m3d),
89 TAtt3D(m3d),
90 fX(m3d.fX),
91 fY(m3d.fY),
92 fZ(m3d.fZ),
93 fDx(m3d.fDx),
94 fDy(m3d.fDy),
95 fDz(m3d.fDz),
96 fTheta(m3d.fTheta),
97 fPhi(m3d.fPhi),
98 fRefObject(m3d.fRefObject)
99{
100}
101
102////////////////////////////////////////////////////////////////////////////////
103/// assignment operator
104
106{
107 if(this!=&m3d) {
112 fX=m3d.fX;
113 fY=m3d.fY;
114 fZ=m3d.fZ;
115 fDx=m3d.fDx;
116 fDy=m3d.fDy;
117 fDz=m3d.fDz;
118 fTheta=m3d.fTheta;
119 fPhi=m3d.fPhi;
121 }
122 return *this;
123}
124
125////////////////////////////////////////////////////////////////////////////////
126/// Marker3DBox shape default destructor
127
129{
130}
131
132
133////////////////////////////////////////////////////////////////////////////////
134/// Compute distance from point px,py to a Marker3DBox
135///
136/// Compute the closest distance of approach from point px,py to each corner
137/// point of the Marker3DBox.
138
140{
141 const Int_t numPoints = 8;
142 Int_t dist = 9999;
143 Double_t points[3*numPoints];
144
145 TView *view = gPad->GetView();
146 if (!view) return dist;
147 const Int_t seg1[12] = {0,1,2,3,4,5,6,7,0,1,2,3};
148 const Int_t seg2[12] = {1,2,3,0,5,6,7,4,4,5,6,7};
149
151
152 Int_t i, i1, i2, dsegment;
154 Double_t xndc[3];
155 for (i = 0; i < 12; i++) {
156 i1 = 3*seg1[i];
157 view->WCtoNDC(&points[i1], xndc);
158 x1 = xndc[0];
159 y1 = xndc[1];
160
161 i2 = 3*seg2[i];
162 view->WCtoNDC(&points[i2], xndc);
163 x2 = xndc[0];
164 y2 = xndc[1];
165 dsegment = DistancetoLine(px,py,x1,y1,x2,y2);
166 if (dsegment < dist) dist = dsegment;
167 }
168 if (dist < 5) {
169 gPad->SetCursor(kCross);
170 if (fRefObject) {gPad->SetSelected(fRefObject); return 0;}
171 }
172 return dist;
173}
174
175////////////////////////////////////////////////////////////////////////////////
176/// Execute action corresponding to one event
177///
178/// This member function must be implemented to realize the action
179/// corresponding to the mouse click on the object in the window
180
182{
183 if (!gPad) return;
184 if (gPad->GetView()) gPad->GetView()->ExecuteRotateView(event, px, py);
185}
186
187////////////////////////////////////////////////////////////////////////////////
188/// Paint marker 3D box.
189
190void TMarker3DBox::Paint(Option_t * /* option */ )
191{
192 static TBuffer3D buffer(TBuffer3DTypes::kGeneric);
193
194 buffer.ClearSectionsValid();
195
196 // Section kCore
197
198 // If we are just a temporary object then no 'real object' to
199 // pass to viewer
200 if (TestBit(kTemporary)) {
201 buffer.fID = 0;
202 } else {
203 buffer.fID = this;
204 }
205 buffer.fColor = GetLineColor();
206 buffer.fTransparency = 0;
207 buffer.fLocalFrame = kFALSE;
209
210 // We fill kCore and kRawSizes on first pass and try with viewer
211 TVirtualViewer3D * viewer3D = gPad->GetViewer3D();
212 if (!viewer3D) return;
213 Int_t reqSections = viewer3D->AddObject(buffer);
214 if (reqSections == TBuffer3D::kNone) {
215 return;
216 }
217
218 if (reqSections & TBuffer3D::kRawSizes) {
219 Int_t nbPnts = 8;
220 Int_t nbSegs = 12;
221 Int_t nbPols = 6;
222 if (!buffer.SetRawSizes(nbPnts, 3*nbPnts, nbSegs, 3*nbSegs, nbPols, 6*nbPols)) {
223 return;
224 }
226 }
227
228 if ((reqSections & TBuffer3D::kRaw) && buffer.SectionsValid(TBuffer3D::kRawSizes)) {
229 // Points
230 SetPoints(buffer.fPnts);
231
232 // Transform points
233 if (gGeometry && !buffer.fLocalFrame) {
234 Double_t dlocal[3];
235 Double_t dmaster[3];
236 for (UInt_t j=0; j<buffer.NbPnts(); j++) {
237 dlocal[0] = buffer.fPnts[3*j];
238 dlocal[1] = buffer.fPnts[3*j+1];
239 dlocal[2] = buffer.fPnts[3*j+2];
240 gGeometry->Local2Master(&dlocal[0],&dmaster[0]);
241 buffer.fPnts[3*j] = dmaster[0];
242 buffer.fPnts[3*j+1] = dmaster[1];
243 buffer.fPnts[3*j+2] = dmaster[2];
244 }
245 }
246
247 // Basic colors: 0, 1, ... 8
248 Int_t c = (((GetLineColor()) %8) -1) * 4;
249 if (c < 0) c = 0;
250
251 // Segments
252 buffer.fSegs[ 0] = c ; buffer.fSegs[ 1] = 0 ; buffer.fSegs[ 2] = 1;
253 buffer.fSegs[ 3] = c+1 ; buffer.fSegs[ 4] = 1 ; buffer.fSegs[ 5] = 2;
254 buffer.fSegs[ 6] = c+1 ; buffer.fSegs[ 7] = 2 ; buffer.fSegs[ 8] = 3;
255 buffer.fSegs[ 9] = c ; buffer.fSegs[10] = 3 ; buffer.fSegs[11] = 0;
256 buffer.fSegs[12] = c+2 ; buffer.fSegs[13] = 4 ; buffer.fSegs[14] = 5;
257 buffer.fSegs[15] = c+2 ; buffer.fSegs[16] = 5 ; buffer.fSegs[17] = 6;
258 buffer.fSegs[18] = c+3 ; buffer.fSegs[19] = 6 ; buffer.fSegs[20] = 7;
259 buffer.fSegs[21] = c+3 ; buffer.fSegs[22] = 7 ; buffer.fSegs[23] = 4;
260 buffer.fSegs[24] = c ; buffer.fSegs[25] = 0 ; buffer.fSegs[26] = 4;
261 buffer.fSegs[27] = c+2 ; buffer.fSegs[28] = 1 ; buffer.fSegs[29] = 5;
262 buffer.fSegs[30] = c+1 ; buffer.fSegs[31] = 2 ; buffer.fSegs[32] = 6;
263 buffer.fSegs[33] = c+3 ; buffer.fSegs[34] = 3 ; buffer.fSegs[35] = 7;
264
265 // Polygons
266 buffer.fPols[ 0] = c ; buffer.fPols[ 1] = 4 ; buffer.fPols[ 2] = 0;
267 buffer.fPols[ 3] = 9 ; buffer.fPols[ 4] = 4 ; buffer.fPols[ 5] = 8;
268 buffer.fPols[ 6] = c+1 ; buffer.fPols[ 7] = 4 ; buffer.fPols[ 8] = 1;
269 buffer.fPols[ 9] = 10 ; buffer.fPols[10] = 5 ; buffer.fPols[11] = 9;
270 buffer.fPols[12] = c ; buffer.fPols[13] = 4 ; buffer.fPols[14] = 2;
271 buffer.fPols[15] = 11 ; buffer.fPols[16] = 6 ; buffer.fPols[17] = 10;
272 buffer.fPols[18] = c+1 ; buffer.fPols[19] = 4 ; buffer.fPols[20] = 3;
273 buffer.fPols[21] = 8 ; buffer.fPols[22] = 7 ; buffer.fPols[23] = 11;
274 buffer.fPols[24] = c+2 ; buffer.fPols[25] = 4 ; buffer.fPols[26] = 0;
275 buffer.fPols[27] = 3 ; buffer.fPols[28] = 2 ; buffer.fPols[29] = 1;
276 buffer.fPols[30] = c+3 ; buffer.fPols[31] = 4 ; buffer.fPols[32] = 4;
277 buffer.fPols[33] = 5 ; buffer.fPols[34] = 6 ; buffer.fPols[35] = 7;
278
280
283 }
284
285 viewer3D->AddObject(buffer);
286}
287
288////////////////////////////////////////////////////////////////////////////////
289/// Paint 3-d histogram h with marker3dboxes
290
292{
293 Int_t bin,ix,iy,iz;
294 Double_t xmin,xmax,ymin,ymax,zmin,zmax,wmin,wmax,w;
295 TAxis *xaxis = h->GetXaxis();
296 TAxis *yaxis = h->GetYaxis();
297 TAxis *zaxis = h->GetZaxis();
298
299 wmin = h->GetMinimum();
300 wmax = h->GetMaximum();
301
302 //Create or modify 3-d view object
303 TView *view = gPad->GetView();
304 if (!view) {
305 gPad->Range(-1,-1,1,1);
306 view = TView::CreateView(1,0,0);
307 if (!view) return;
308 }
309 view->SetRange(xaxis->GetBinLowEdge(xaxis->GetFirst()),
310 yaxis->GetBinLowEdge(yaxis->GetFirst()),
311 zaxis->GetBinLowEdge(zaxis->GetFirst()),
312 xaxis->GetBinUpEdge(xaxis->GetLast()),
313 yaxis->GetBinUpEdge(yaxis->GetLast()),
314 zaxis->GetBinUpEdge(zaxis->GetLast()));
315
316 view->PadRange(gPad->GetFrameFillColor());
317
318 //Draw TMarker3DBox with size proportional to cell content
320 m3.SetBit(kTemporary,kTRUE);
321 m3.SetRefObject(h);
322 m3.SetDirection(0,0);
323 m3.SetLineColor(h->GetMarkerColor());
324 Double_t scale;
325 for (ix=xaxis->GetFirst();ix<=xaxis->GetLast();ix++) {
326 xmin = h->GetXaxis()->GetBinLowEdge(ix);
327 xmax = xmin + h->GetXaxis()->GetBinWidth(ix);
328 for (iy=yaxis->GetFirst();iy<=yaxis->GetLast();iy++) {
329 ymin = h->GetYaxis()->GetBinLowEdge(iy);
330 ymax = ymin + h->GetYaxis()->GetBinWidth(iy);
331 for (iz=zaxis->GetFirst();iz<=zaxis->GetLast();iz++) {
332 zmin = h->GetZaxis()->GetBinLowEdge(iz);
333 zmax = zmin + h->GetZaxis()->GetBinWidth(iz);
334 bin = h->GetBin(ix,iy,iz);
335 w = h->GetBinContent(bin);
336 if (w < wmin) continue;
337 if (w > wmax) w = wmax;
338 scale = (TMath::Power((w-wmin)/(wmax-wmin),1./3.))/2.;
339 if (scale == 0) continue;
340 m3.SetPosition(0.5*(xmin+xmax),0.5*(ymin+ymax),0.5*(zmin+zmax));
341 m3.SetSize(scale*(xmax-xmin),scale*(ymax-ymin),scale*(zmax-zmin));
342 m3.Paint(option);
343 }
344 }
345 }
346}
347
348////////////////////////////////////////////////////////////////////////////////
349/// Save primitive as a C++ statement(s) on output stream out
350
351void TMarker3DBox::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
352{
353 out<<" "<<std::endl;
354 if (gROOT->ClassSaved(TMarker3DBox::Class())) {
355 out<<" ";
356 } else {
357 out<<" TMarker3DBox *";
358 }
359 out<<"marker3DBox = new TMarker3DBox("<<fX<<","
360 <<fY<<","
361 <<fZ<<","
362 <<fDx<<","
363 <<fDy<<","
364 <<fDz<<","
365 <<fTheta<<","
366 <<fPhi<<");"<<std::endl;
367
368 SaveLineAttributes(out,"marker3DBox",1,1,1);
369 SaveFillAttributes(out,"marker3DBox",1,0);
370
371 out<<" marker3DBox->Draw();"<<std::endl;
372}
373
374////////////////////////////////////////////////////////////////////////////////
375/// Set direction.
376
378{
379 fTheta = theta;
380 fPhi = phi;
381}
382
383////////////////////////////////////////////////////////////////////////////////
384/// Set size.
385
387{
388 fDx = dx;
389 fDy = dy;
390 fDz = dz;
391}
392
393////////////////////////////////////////////////////////////////////////////////
394/// Set position.
395
397{
398 fX = x;
399 fY = y;
400 fZ = z;
401}
402
403////////////////////////////////////////////////////////////////////////////////
404/// Set points.
405
407{
408 if (points) {
409 points[ 0] = -fDx ; points[ 1] = -fDy ; points[ 2] = -fDz;
410 points[ 3] = -fDx ; points[ 4] = fDy ; points[ 5] = -fDz;
411 points[ 6] = fDx ; points[ 7] = fDy ; points[ 8] = -fDz;
412 points[ 9] = fDx ; points[10] = -fDy ; points[11] = -fDz;
413 points[12] = -fDx ; points[13] = -fDy ; points[14] = fDz;
414 points[15] = -fDx ; points[16] = fDy ; points[17] = fDz;
415 points[18] = fDx ; points[19] = fDy ; points[20] = fDz;
416 points[21] = fDx ; points[22] = -fDy ; points[23] = fDz;
417
418 Double_t x, y, z;
419 const Double_t kPI = TMath::Pi();
420 Double_t theta = fTheta*kPI/180;
421 Double_t phi = fPhi*kPI/180;
422 Double_t sinth = TMath::Sin(theta);
423 Double_t costh = TMath::Cos(theta);
424 Double_t sinfi = TMath::Sin(phi);
425 Double_t cosfi = TMath::Cos(phi);
426
427 // Matrix to convert from fruit frame to master frame
428 Double_t m[9];
429 m[0] = costh * cosfi; m[1] = -sinfi; m[2] = sinth*cosfi;
430 m[3] = costh * sinfi; m[4] = cosfi; m[5] = sinth*sinfi;
431 m[6] = -sinth; m[7] = 0; m[8] = costh;
432 for (Int_t i = 0; i < 8; i++) {
433 x = points[3*i];
434 y = points[3*i+1];
435 z = points[3*i+2];
436
437 points[3*i] = fX + m[0] * x + m[1] * y + m[2] * z;
438 points[3*i+1] = fY + m[3] * x + m[4] * y + m[5] * z;
439 points[3*i+2] = fZ + m[6] * x + m[7] * y + m[8] * z;
440 }
441 }
442}
443
444////////////////////////////////////////////////////////////////////////////////
445/// Stream an object of class TMarker3DBox.
446
448{
449 if (R__b.IsReading()) {
450 UInt_t R__s, R__c;
451 Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
452 if (R__v > 1) {
453 R__b.ReadClassBuffer(TMarker3DBox::Class(), this, R__v, R__s, R__c);
454 return;
455 }
456 //====process old versions before automatic schema evolution
457 TObject::Streamer(R__b);
458 TAttLine::Streamer(R__b);
459 TAttFill::Streamer(R__b);
460 TAtt3D::Streamer(R__b);
461 R__b >> fX;
462 R__b >> fY;
463 R__b >> fZ;
464 R__b >> fDx;
465 R__b >> fDy;
466 R__b >> fDz;
467 R__b >> fTheta;
468 R__b >> fPhi;
469 R__b >> fRefObject;
470 R__b.CheckByteCount(R__s, R__c, TMarker3DBox::IsA());
471 //====end of old versions
472
473 } else {
475 }
476}
@ kCross
Definition: GuiTypes.h:374
#define c(i)
Definition: RSha256.hxx:101
#define h(i)
Definition: RSha256.hxx:106
short Version_t
Definition: RtypesCore.h:65
const Bool_t kFALSE
Definition: RtypesCore.h:101
float Float_t
Definition: RtypesCore.h:57
const Bool_t kTRUE
Definition: RtypesCore.h:100
const char Option_t
Definition: RtypesCore.h:66
#define ClassImp(name)
Definition: Rtypes.h:375
const Double_t kPI
Definition: TEllipse.cxx:24
Option_t Option_t option
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t wmin
Option_t Option_t TPoint TPoint const char x2
Option_t Option_t TPoint TPoint const char x1
Option_t Option_t TPoint TPoint const char y2
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t points
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t wmax
Option_t Option_t TPoint TPoint const char y1
R__EXTERN TGeometry * gGeometry
Definition: TGeometry.h:158
float xmin
Definition: THbookFile.cxx:95
float ymin
Definition: THbookFile.cxx:95
float xmax
Definition: THbookFile.cxx:95
float ymax
Definition: THbookFile.cxx:95
Binding & operator=(OUT(*fun)(void))
#define gROOT
Definition: TROOT.h:404
#define gPad
Definition: TVirtualPad.h:288
Use this attribute class when an object should have 3D capabilities.
Definition: TAtt3D.h:19
virtual void Streamer(TBuffer &)
Fill Area Attributes class.
Definition: TAttFill.h:19
virtual void Streamer(TBuffer &)
virtual void Modify()
Change current fill area attributes if necessary.
Definition: TAttFill.cxx:213
virtual void SaveFillAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1001)
Save fill attributes as C++ statement(s) on output stream out.
Definition: TAttFill.cxx:236
Line Attributes class.
Definition: TAttLine.h:18
virtual void Streamer(TBuffer &)
virtual Color_t GetLineColor() const
Return the line color.
Definition: TAttLine.h:33
virtual void Modify()
Change current line attributes if necessary.
Definition: TAttLine.cxx:245
Int_t DistancetoLine(Int_t px, Int_t py, Double_t xp1, Double_t yp1, Double_t xp2, Double_t yp2)
Compute distance from point px,py to a line.
Definition: TAttLine.cxx:209
virtual void SaveLineAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t widdef=1)
Save line attributes as C++ statement(s) on output stream out.
Definition: TAttLine.cxx:273
Class to manage histogram axis.
Definition: TAxis.h:30
virtual Double_t GetBinLowEdge(Int_t bin) const
Return low edge of bin.
Definition: TAxis.cxx:518
Int_t GetLast() const
Return last bin on the axis i.e.
Definition: TAxis.cxx:469
virtual Double_t GetBinUpEdge(Int_t bin) const
Return up edge of bin.
Definition: TAxis.cxx:528
Int_t GetFirst() const
Return first bin on the axis i.e.
Definition: TAxis.cxx:458
Generic 3D primitive description class.
Definition: TBuffer3D.h:18
Int_t * fPols
Definition: TBuffer3D.h:114
UInt_t NbPnts() const
Definition: TBuffer3D.h:80
Bool_t SectionsValid(UInt_t mask) const
Definition: TBuffer3D.h:67
@ kRawSizes
Definition: TBuffer3D.h:53
void ClearSectionsValid()
Clear any sections marked valid.
Definition: TBuffer3D.cxx:286
void SetSectionsValid(UInt_t mask)
Definition: TBuffer3D.h:65
Int_t * fSegs
Definition: TBuffer3D.h:113
Bool_t fLocalFrame
Definition: TBuffer3D.h:90
Int_t fColor
Definition: TBuffer3D.h:88
Short_t fTransparency
Definition: TBuffer3D.h:89
TObject * fID
Definition: TBuffer3D.h:87
Bool_t SetRawSizes(UInt_t reqPnts, UInt_t reqPntsCapacity, UInt_t reqSegs, UInt_t reqSegsCapacity, UInt_t reqPols, UInt_t reqPolsCapacity)
Set kRaw tessellation section of buffer with supplied sizes.
Definition: TBuffer3D.cxx:359
Double_t * fPnts
Definition: TBuffer3D.h:112
Buffer base class used for serializing objects.
Definition: TBuffer.h:43
virtual Version_t ReadVersion(UInt_t *start=nullptr, UInt_t *bcnt=nullptr, const TClass *cl=nullptr)=0
virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss)=0
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=nullptr)=0
Bool_t IsReading() const
Definition: TBuffer.h:86
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
virtual void Local2Master(Double_t *local, Double_t *master)
Convert one point from local system to master reference system.
Definition: TGeometry.cxx:407
TH1 is the base class of all histogram classes in ROOT.
Definition: TH1.h:58
A special 3-D marker designed for event display.
Definition: TMarker3DBox.h:38
virtual void Streamer(TBuffer &)
Stream an object of class TMarker3DBox.
Float_t fDy
Definition: TMarker3DBox.h:44
virtual void SetPoints(Double_t *buff) const
Set points.
Float_t fDx
Definition: TMarker3DBox.h:43
virtual void SetSize(Float_t dx, Float_t dy, Float_t dz)
Set size.
TMarker3DBox & operator=(const TMarker3DBox &)
assignment operator
Float_t fX
Definition: TMarker3DBox.h:40
static void PaintH3(TH1 *h, Option_t *option)
Paint 3-d histogram h with marker3dboxes.
Float_t fY
Definition: TMarker3DBox.h:41
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
Compute distance from point px,py to a Marker3DBox.
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save primitive as a C++ statement(s) on output stream out.
static TClass * Class()
Float_t fZ
Definition: TMarker3DBox.h:42
Float_t fDz
Definition: TMarker3DBox.h:45
virtual void SetDirection(Float_t theta, Float_t phi)
Set direction.
virtual void SetPosition(Float_t x, Float_t y, Float_t z)
Set position.
virtual TClass * IsA() const
Definition: TMarker3DBox.h:79
TMarker3DBox()
Marker3DBox default constructor.
virtual void Paint(Option_t *option)
Paint marker 3D box.
Float_t fPhi
Definition: TMarker3DBox.h:48
Float_t fTheta
Definition: TMarker3DBox.h:47
virtual ~TMarker3DBox()
Marker3DBox shape default destructor.
TObject * fRefObject
Definition: TMarker3DBox.h:49
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py)
Execute action corresponding to one event.
Mother of all ROOT objects.
Definition: TObject.h:41
TObject & operator=(const TObject &rhs)
TObject assignment operator.
Definition: TObject.h:298
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:201
virtual void Streamer(TBuffer &)
Stream an object of class TObject.
Definition: TObject.cxx:876
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:768
See TView3D.
Definition: TView.h:25
virtual void WCtoNDC(const Float_t *pw, Float_t *pn)=0
static TView * CreateView(Int_t system=1, const Double_t *rmin=nullptr, const Double_t *rmax=nullptr)
Create a concrete default 3-d view via the plug-in manager.
Definition: TView.cxx:27
virtual void PadRange(Int_t rback)=0
virtual void SetRange(const Double_t *min, const Double_t *max)=0
Abstract 3D shapes viewer.
virtual Int_t AddObject(const TBuffer3D &buffer, Bool_t *addChildren=nullptr)=0
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
double dist(Rotation3D const &r1, Rotation3D const &r2)
Definition: 3DDistances.cxx:48
static constexpr double m3
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Returns x raised to the power y.
Definition: TMath.h:719
Double_t Cos(Double_t)
Returns the cosine of an angle of x radians.
Definition: TMath.h:592
constexpr Double_t Pi()
Definition: TMath.h:37
Double_t Sin(Double_t)
Returns the sine of an angle of x radians.
Definition: TMath.h:586
TMarker m
Definition: textangle.C:8