forked from root-project/root
-
Notifications
You must be signed in to change notification settings - Fork 0
/
TEveTrans.h
186 lines (138 loc) · 6.42 KB
/
TEveTrans.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
// @(#)root/eve:$Id$
// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
/*************************************************************************
* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
#ifndef ROOT_TEveTrans
#define ROOT_TEveTrans
#include "TEveVector.h"
#include "TVector3.h"
class TGeoMatrix;
class TGeoHMatrix;
class TBuffer3D;
/******************************************************************************/
// TEveTrans -- 3D transformation in generalised coordinates
/******************************************************************************/
class TEveTrans : public TObject
{
friend class TEveTransSubEditor;
friend class TEveTransEditor;
protected:
Double32_t fM[16];
mutable Float_t fA1; //!
mutable Float_t fA2; //!
mutable Float_t fA3; //!
mutable Bool_t fAsOK; //!
// TEveUtil
Bool_t fUseTrans; // use transformation matrix
Bool_t fEditTrans; // edit transformation in TGedFrame
Bool_t fEditRotation; // edit rotation
Bool_t fEditScale; // edit scale
Double_t Norm3Column(Int_t col);
Double_t Orto3Column(Int_t col, Int_t ref);
public:
TEveTrans();
TEveTrans(const TEveTrans& t);
TEveTrans(const Double_t arr[16]);
TEveTrans(const Float_t arr[16]);
virtual ~TEveTrans() {}
// General operations
void UnitTrans();
void ZeroTrans(Double_t w=1.0);
void UnitRot();
void SetTrans(const TEveTrans& t, Bool_t copyAngles=kTRUE);
void SetFromArray(const Double_t arr[16]);
void SetFromArray(const Float_t arr[16]);
TEveTrans& operator=(const TEveTrans& t) { SetTrans(t); return *this; }
void SetupRotation(Int_t i, Int_t j, Double_t f);
void SetupFromToVec(const TEveVector& from, const TEveVector& to);
void OrtoNorm3();
Double_t Invert();
void MultLeft(const TEveTrans& t);
void MultRight(const TEveTrans& t);
void operator*=(const TEveTrans& t) { MultRight(t); }
void TransposeRotationPart();
TEveTrans operator*(const TEveTrans& t);
// Move & Rotate
void MoveLF(Int_t ai, Double_t amount);
void Move3LF(Double_t x, Double_t y, Double_t z);
void RotateLF(Int_t i1, Int_t i2, Double_t amount);
void MovePF(Int_t ai, Double_t amount);
void Move3PF(Double_t x, Double_t y, Double_t z);
void RotatePF(Int_t i1, Int_t i2, Double_t amount);
void Move(const TEveTrans& a, Int_t ai, Double_t amount);
void Move3(const TEveTrans& a, Double_t x, Double_t y, Double_t z);
void Rotate(const TEveTrans& a, Int_t i1, Int_t i2, Double_t amount);
// Element access
Double_t* Array() { return fM; } const Double_t* Array() const { return fM; }
Double_t* ArrX() { return fM; } const Double_t* ArrX() const { return fM; }
Double_t* ArrY() { return fM + 4; } const Double_t* ArrY() const { return fM + 4; }
Double_t* ArrZ() { return fM + 8; } const Double_t* ArrZ() const { return fM + 8; }
Double_t* ArrT() { return fM + 12; } const Double_t* ArrT() const { return fM + 12; }
Double_t operator[](Int_t i) const { return fM[i]; }
Double_t& operator[](Int_t i) { return fM[i]; }
Double_t CM(Int_t i, Int_t j) const { return fM[4*j + i]; }
Double_t& CM(Int_t i, Int_t j) { return fM[4*j + i]; }
Double_t operator()(Int_t i, Int_t j) const { return fM[4*j + i - 5]; }
Double_t& operator()(Int_t i, Int_t j) { return fM[4*j + i - 5]; }
// Base-vector interface
void SetBaseVec(Int_t b, Double_t x, Double_t y, Double_t z);
void SetBaseVec(Int_t b, const TVector3& v);
TVector3 GetBaseVec(Int_t b) const;
void GetBaseVec(Int_t b, TVector3& v) const;
// Position interface
void SetPos(Double_t x, Double_t y, Double_t z);
void SetPos(Double_t* x);
void SetPos(Float_t * x);
void SetPos(const TEveTrans& t);
void GetPos(Double_t& x, Double_t& y, Double_t& z) const;
void GetPos(Double_t* x) const;
void GetPos(Float_t * x) const;
void GetPos(TVector3& v) const;
TVector3 GetPos() const;
// Cardan angle interface
void SetRotByAngles(Float_t a1, Float_t a2, Float_t a3);
void SetRotByAnyAngles(Float_t a1, Float_t a2, Float_t a3, const char* pat);
void GetRotAngles(Float_t* x) const;
// Scaling
void Scale(Double_t sx, Double_t sy, Double_t sz);
Double_t Unscale();
void Unscale(Double_t& sx, Double_t& sy, Double_t& sz);
void GetScale(Double_t& sx, Double_t& sy, Double_t& sz) const;
void SetScale(Double_t sx, Double_t sy, Double_t sz);
void SetScaleX(Double_t sx);
void SetScaleY(Double_t sy);
void SetScaleZ(Double_t sz);
// Operations on vectors
void MultiplyIP(TVector3& v, Double_t w=1) const;
void MultiplyIP(Double_t* v, Double_t w=1) const;
void MultiplyIP(Float_t* v, Double_t w=1) const;
TVector3 Multiply(const TVector3& v, Double_t w=1) const;
void Multiply(const Double_t *vin, Double_t* vout, Double_t w=1) const;
void RotateIP(TVector3& v) const;
void RotateIP(Double_t* v) const;
void RotateIP(Float_t* v) const;
TVector3 Rotate(const TVector3& v) const;
virtual void Print(Option_t* option = "") const;
// TEveUtil stuff
void SetFrom(Double_t* carr);
void SetFrom(const TGeoMatrix& mat);
void SetGeoHMatrix(TGeoHMatrix& mat);
void SetBuffer3D(TBuffer3D& buff);
Bool_t GetUseTrans() const { return fUseTrans; }
void SetUseTrans(Bool_t v) { fUseTrans = v; }
void SetEditRotation(Bool_t x){ fEditRotation = x; }
void SetEditScale(Bool_t x) { fEditScale = x; }
Bool_t GetEditRotation() { return fEditRotation; }
Bool_t GetEditScale() { return fEditScale; }
Bool_t GetEditTrans() const { return fEditTrans; }
void SetEditTrans(Bool_t v) { fEditTrans = v; }
Bool_t IsScale(Double_t low=0.9, Double_t high=1.1) const;
ClassDef(TEveTrans, 1); // Column-major 4x4 transforamtion matrix for homogeneous coordinates.
};
std::ostream& operator<<(std::ostream& s, const TEveTrans& t);
#endif