ROOT logo
Gled » GLEDCORE » HTrans<float>

class HTrans<float>

 HPoint -- a simple 3D point

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

HTransF::TP, 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
floatCM(Int_t i, Int_t j) const
float&CM(Int_t i, Int_t j)
HPoint<float>GetBaseVec(Int_t b) const
voidGetBaseVec(Int_t b, Float_t* x) const
voidGetBaseVec(Int_t b, Double_t* x) const
HPoint<float>GetPos() const
voidGetPos(Float_t* x) const
voidGetPos(Double_t* x) const
voidGetPos(float& x, float& y, float& z) const
voidGetRotAngles(Float_t* x) const
voidGetScale(float& sx, float& sy, float& sz) const
floatInvert()
floatInvertWithoutRow4()
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)
HPoint<float>Multiply(const HPoint<float>& v, float w = 1) const
voidMultiplyIP(HPoint<float>& 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>&)
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() 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()
HPoint<float>Rotate(const HPoint<float>& v) const
voidRotate(const HTrans<float>& a, Int_t i1, Int_t i2, float amount)
voidRotateBackVec3(const float* in, float* out) const
voidRotateIP(HPoint<float>& 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_t* x)
voidSetBaseVec(Int_t b, Double_t* x)
voidSetBaseVec(Int_t b, float x, float y, float z)
voidSetBaseVecViaCross(Int_t i)
voidSetFromArray(const Float_t* arr)
voidSetFromArray(const Double_t* arr)
voidSetPos(const Float_t* x)
voidSetPos(const Double_t* 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)
voidTranspose()
voidTransposeRotationPart()
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 Print() const
HPoint<TT> operator*(const HPoint<TT>& a, TT b)
TT* Array()
 Element access
TT* ArrX()
TT* ArrY()
TT* ArrZ()
TT* ArrT()
TT operator[](Int_t i) const
{ return M[i]; }
TT& operator[](Int_t i)
{ return M[i]; }
TT CM(Int_t i, Int_t j) const
{ 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) const
{ return M[4*j + i - 5]; }
TT& operator()(Int_t i, Int_t j)
{ return M[4*j + i - 5]; }
void UnitTrans()
 General operations
void UnitRot()
void SetTrans(const HTrans<float>& t)
void SetFromArray(const Float_t* arr)
void SetFromArray(const Double_t* arr)
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()
void TransposeRotationPart()
TT Invert()
TT InvertWithoutRow4()
void MultLeft(const HTrans<float>& t)
void MultRight(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)
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, const HPoint<OO>& v)
{ SetBaseVec(b, v.x, v.y, v.z); }
void SetBaseVec(Int_t b, Float_t* x)
{ TT* C = M + 4*--b; C[0] = x[0]; C[1] = x[1]; C[2] = x[2]; }
TT* PtrBaseVec(Int_t b)
{ return &M[4*(b-1)]; }
const TT* PtrBaseVec(Int_t b) const
{ return &M[4*(b-1)]; }
TT* PtrBaseVecX()
{ return &M[0]; }
const TT* PtrBaseVecX() const
{ return &M[0]; }
TT* PtrBaseVecY()
{ return &M[4]; }
const TT* PtrBaseVecY() const
{ return &M[4]; }
TT* PtrBaseVecZ()
{ return &M[8]; }
const TT* PtrBaseVecZ() const
{ return &M[8]; }
HPoint<TT> GetBaseVec(Int_t b) const
{ const TT* C = M + 4*--b; return HPoint<TT>(C[0], C[1], C[2]); }
void GetBaseVec(Int_t b, Float_t* x) const
{ const TT* C = M + 4*--b; x[0] = C[0], x[1] = C[1], x[2] = C[2]; }
void GetBaseVec(Int_t b, Double_t* x) const
{ const TT* C = M + 4*--b; x[0] = C[0], x[1] = C[1], x[2] = C[2]; }
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(const HPoint<OO>& v)
{ SetPos(v.x, v.y, v.z); }
void SetPos(const Float_t* x)
{ SetPos(x[0], x[1], x[2]); }
void SetPos(const Double_t* x)
{ SetPos(x[0], x[1], x[2]); }
void GetPos(float& x, float& y, float& z) const
{ x = M[12]; y = M[13]; z = M[14]; }
HPoint<TT> GetPos() const
{ return HPoint<TT>(M[12], M[13], M[14]); }
void GetPos(Float_t* x) const
{ x[0] = M[12]; x[1] = M[13]; x[2] = M[14]; }
void GetPos(Double_t* x) const
{ x[0] = M[12]; x[1] = M[13]; x[2] = M[14]; }
TT* PtrPos()
{ return &M[12]; }
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(HPoint<float>& v, float w = 1) const
 Operations on vectors
void RotateIP(HPoint<float>& v) const
HPoint<TT> Multiply(const HPoint<float>& v, float w = 1) const
HPoint<TT> Rotate(const HPoint<float>& 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