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