ROOT logo
Gled » VAR1 » HTrans<float>

class HTrans<float>

This class is also known as (typedefs to this class)

HTrans<Float_t>

Function Members (Methods)

public:
HTrans<float>()
HTrans<float>(const HTrans<float>& z)
HTrans<float>(const Float_t* x)
HTrans<float>(const Double_t* x)
~HTrans<float>()
float*Array()
const float*Array() const
float*ArrT()
const float*ArrT() const
float*ArrX()
const float*ArrX() const
float*ArrY()
const float*ArrY() const
float*ArrZ()
const float*ArrZ() const
static TClass*Class()
floatCM(Int_t i, Int_t j) const
float&CM(Int_t i, Int_t j)
TVector3GetBaseVec(Int_t b) const
voidGetBaseVec(Int_t b, float* x) const
voidGetBaseVec(Int_t b, TVector3& v) const
TVector3GetPos() const
voidGetPos(float* x) const
voidGetPos(TVector3& v) const
voidGetPos(float& x, float& y, float& z) const
voidGetRotAngles(Float_t* x) const
voidGetScale(float& sx, float& sy, float& sz) const
floatInvert()
floatInvertWithoutRow4()
TClass*IsA() const
voidMove(const HTrans<float>& a, Int_t ai, float amount)
voidMove3(const HTrans<float>& a, float x, float y, float z)
voidMove3LF(float x, float y, float z)
voidMove3PF(float x, float y, float z)
voidMoveLF(Int_t ai, float amount)
voidMovePF(Int_t ai, float amount)
TVector3Multiply(const TVector3& v, float w = 1) const
voidMultiplyIP(TVector3& v, float w = 1) const
voidMultiplyVec3(const float* in, float w, float* out) const
voidMultiplyVec3IP(float* in, float w) const
voidMultLeft(const HTrans<float>& t)
voidMultLeft3x3(const float* m)
voidMultLeft3x3transposed(const float* m)
voidMultRight(const HTrans<float>& t)
voidMultRight3x3(const float* m)
voidMultRight3x3transposed(const float* m)
floatNorm3Column(Int_t col)
const float*operator const float*() const
float*operator float*()
floatoperator()(Int_t i, Int_t j) const
float&operator()(Int_t i, Int_t j)
HTrans<float>operator*(const HTrans<float>& t)
voidoperator*=(const HTrans<float>& t)
HTrans<float>&operator=(const HTrans<float>& t)
floatoperator[](Int_t i) const
float&operator[](Int_t i)
floatOrto3Column(Int_t col, Int_t ref)
voidOrtoNorm3()
floatOrtoNorm3Column(Int_t col, Int_t ref)
voidPrint(Option_t* option = "") const
float*PtrBaseVec(Int_t b)
const float*PtrBaseVec(Int_t b) const
float*PtrBaseVecX()
const float*PtrBaseVecX() const
float*PtrBaseVecY()
const float*PtrBaseVecY() const
float*PtrBaseVecZ()
const float*PtrBaseVecZ() const
float*PtrPos()
TVector3Rotate(const TVector3& v) const
voidRotate(const HTrans<float>& a, Int_t i1, Int_t i2, float amount)
voidRotateBackVec3(const float* in, float* out) const
voidRotateIP(TVector3& v) const
voidRotateLF(Int_t i1, Int_t i2, float amount)
voidRotatePF(Int_t i1, Int_t i2, float amount)
voidRotateVec3(const float* in, float* out) const
voidRotateVec3IP(float* in) const
voidScale(float sx, float sy, float sz)
voidSetBaseVec(Int_t b, float* x)
voidSetBaseVec(Int_t b, const TVector3& v)
voidSetBaseVec(Int_t b, float x, float y, float z)
voidSetBaseVecViaCross(Int_t i)
voidSetPos(float* x)
voidSetPos(const HTrans<float>& t)
voidSetPos(float x, float y, float z)
voidSetRotByAngles(Float_t a1, Float_t a2, Float_t a3)
voidSetRotByAnyAngles(Float_t a1, Float_t a2, Float_t a3, const Text_t* pat)
voidSetTrans(const HTrans<float>& t)
voidSetupRotation(Int_t i, Int_t j, float f)
voidShowMembers(TMemberInspector& insp, char* parent)
voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
voidTranspose()
voidUnitRot()
voidUnitTrans()
floatUnscale()
voidUnscale(float& sx, float& sy, float& sz)

Data Members

protected:
floatM[16]

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

HPoint& operator*=(const HTrans<float>& t)
{ x *= f; y *= f; z *= f; return *this; }
void UnitTrans()
 General operations
void UnitRot()
void SetTrans(const HTrans<float>& t)
HTrans& operator=(const HTrans<float>& t)
{ SetTrans(t); return *this; }
void SetupRotation(Int_t i, Int_t j, float f)
TT Norm3Column(Int_t col)
TT Orto3Column(Int_t col, Int_t ref)
TT OrtoNorm3Column(Int_t col, Int_t ref)
void OrtoNorm3()
void SetBaseVecViaCross(Int_t i)
void Transpose()
TT Invert()
TT InvertWithoutRow4()
void MultLeft(const HTrans<float>& t)
void MultRight(const HTrans<float>& t)
HTrans operator*(const HTrans<float>& t)
void MultLeft3x3(const float* m)
void MultRight3x3(const float* m)
void MultLeft3x3transposed(const float* m)
void MultRight3x3transposed(const float* m)
void MoveLF(Int_t ai, float amount)
 Move & Rotate
void Move3LF(float x, float y, float z)
void RotateLF(Int_t i1, Int_t i2, float amount)
void MovePF(Int_t ai, float amount)
void Move3PF(float x, float y, float z)
void RotatePF(Int_t i1, Int_t i2, float amount)
void Move(const HTrans<float>& a, Int_t ai, float amount)
void Move3(const HTrans<float>& a, float x, float y, float z)
void Rotate(const HTrans<float>& a, Int_t i1, Int_t i2, float amount)
TT* Array()
 Element access
TT* ArrX()
TT* ArrY()
TT* ArrZ()
TT* ArrT()
TT operator[](Int_t i)
{ return M[i]; }
TT& operator[](Int_t i)
{ return M[i]; }
TT CM(Int_t i, Int_t j)
{ return M[4*j + i]; }
TT& CM(Int_t i, Int_t j)
{ return M[4*j + i]; }
TT operator()(Int_t i, Int_t j)
{ return M[4*j + i - 5]; }
TT& operator()(Int_t i, Int_t j)
{ return M[4*j + i - 5]; }
void SetBaseVec(Int_t b, float x, float y, float z)
 Base-vector interface
{ TT* C = M + 4*--b; C[0] = x; C[1] = y; C[2] = z; }
void SetBaseVec(Int_t b, TT* x)
{ TT* C = M + 4*--b; C[0] = x[0]; C[1] = x[1]; C[2] = x[2]; }
void SetBaseVec(Int_t b, const TVector3& v)
{ TT* C = M + 4*--b; v.GetXYZ(C); }
TT* PtrBaseVec(Int_t b)
{ return &M[4*(b-1)]; }
const TT* PtrBaseVec(Int_t b)
{ return &M[4*(b-1)]; }
TT* PtrBaseVecX()
{ return &M[0]; }
const TT* PtrBaseVecX()
{ return &M[0]; }
TT* PtrBaseVecY()
{ return &M[4]; }
const TT* PtrBaseVecY()
{ return &M[4]; }
TT* PtrBaseVecZ()
{ return &M[8]; }
const TT* PtrBaseVecZ()
{ return &M[8]; }
void GetBaseVec(Int_t b, TT* x)
{ const TT* C = M + 4*--b; x[0] = C[0], x[1] = C[1], x[2] = C[2]; }
void GetBaseVec(Int_t b, TVector3& v)
{ const TT* C = M + 4*--b; v.SetXYZ(C[0], C[1], C[2]); }
TVector3 GetBaseVec(Int_t b) const
{ return TVector3(&M[4*--b]); }
void SetPos(float x, float y, float z)
 Position interface (can also use base-vec with idx 4)
{ M[12] = x; M[13] = y; M[14] = z; }
void SetPos(TT* x)
{ M[12] = x[0]; M[13] = x[1]; M[14] = x[2]; }
void SetPos(const HTrans& t)
{ M[12] = t[12]; M[13] = t[13]; M[14] = t[14]; }
void GetPos(float& x, float& y, float& z) const
{ x = M[12]; y = M[13]; z = M[14]; }
void GetPos(TT* x)
{ x[0] = M[12]; x[1] = M[13]; x[2] = M[14]; }
TT* PtrPos()
{ return &M[12]; }
void GetPos(TVector3& v)
{ v.SetXYZ(M[12], M[13], M[14]); }
TVector3 GetPos() const
{ return TVector3(M[12], M[13], M[14]); }
void SetRotByAngles(Float_t a1, Float_t a2, Float_t a3)
 Cardan angle interface
void SetRotByAnyAngles(Float_t a1, Float_t a2, Float_t a3, const Text_t* pat)
void GetRotAngles(Float_t* x) const
void Scale(float sx, float sy, float sz)
 Scaling
void GetScale(float& sx, float& sy, float& sz) const
void Unscale(float& sx, float& sy, float& sz)
TT Unscale()
void MultiplyIP(TVector3& v, float w = 1) const
 Operations on vectors
TVector3 Multiply(const TVector3& v, float w = 1) const
void RotateIP(TVector3& v) const
TVector3 Rotate(const TVector3& v) const
void MultiplyVec3IP(float* in, float w) const
void MultiplyVec3(const float* in, float w, float* out) const
void RotateVec3IP(float* in) const
void RotateVec3(const float* in, float* out) const
void RotateBackVec3(const float* in, float* out) const
void Print(Option_t* option = "") const