ROOT logo
Gled » GLEDCORE » HTrans<Double32_t>

class HTrans<Double32_t>

 HPoint -- a simple 3D point

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

ZTrans::TP

Function Members (Methods)

public:
HTrans<Double32_t>()
HTrans<Double32_t>(const HTrans<Double32_t>& z)
HTrans<Double32_t>(const Float_t* x)
HTrans<Double32_t>(const Double_t* x)
~HTrans<Double32_t>()
Double32_t*Array()
const Double32_t*Array() const
Double32_t*ArrT()
const Double32_t*ArrT() const
Double32_t*ArrX()
const Double32_t*ArrX() const
Double32_t*ArrY()
const Double32_t*ArrY() const
Double32_t*ArrZ()
const Double32_t*ArrZ() const
Double32_tCM(Int_t i, Int_t j) const
Double32_t&CM(Int_t i, Int_t j)
HPoint<Double32_t>GetBaseVec(Int_t b) const
voidGetBaseVec(Int_t b, Float_t* x) const
voidGetBaseVec(Int_t b, Double_t* x) const
HPoint<Double32_t>GetPos() const
voidGetPos(Float_t* x) const
voidGetPos(Double_t* x) const
voidGetPos(Double32_t& x, Double32_t& y, Double32_t& z) const
voidGetRotAngles(Float_t* x) const
voidGetScale(Double32_t& sx, Double32_t& sy, Double32_t& sz) const
Double32_tInvert()
Double32_tInvertWithoutRow4()
voidMove(const HTrans<Double32_t>& a, Int_t ai, Double32_t amount)
voidMove3(const HTrans<Double32_t>& a, Double32_t x, Double32_t y, Double32_t z)
voidMove3LF(Double32_t x, Double32_t y, Double32_t z)
voidMove3PF(Double32_t x, Double32_t y, Double32_t z)
voidMoveLF(Int_t ai, Double32_t amount)
voidMovePF(Int_t ai, Double32_t amount)
HPoint<Double32_t>Multiply(const HPoint<Double32_t>& v, Double32_t w = 1) const
voidMultiplyIP(HPoint<Double32_t>& v, Double32_t w = 1) const
voidMultiplyVec3(const Double32_t* in, Double32_t w, Double32_t* out) const
voidMultiplyVec3IP(Double32_t* in, Double32_t w) const
voidMultLeft(const HTrans<Double32_t>& t)
voidMultLeft3x3(const Double32_t* m)
voidMultLeft3x3transposed(const Double32_t* m)
voidMultRight(const HTrans<Double32_t>& t)
voidMultRight3x3(const Double32_t* m)
voidMultRight3x3transposed(const Double32_t* m)
Double32_tNorm3Column(Int_t col)
const Double32_t*operator const Double32_t*() const
Double32_t*operator Double32_t*()
Double32_toperator()(Int_t i, Int_t j) const
Double32_t&operator()(Int_t i, Int_t j)
HTrans<Double32_t>operator*(const HTrans<Double32_t>& t)
voidoperator*=(const HTrans<Double32_t>& t)
HTrans<Double32_t>&operator=(const HTrans<Double32_t>&)
Double32_toperator[](Int_t i) const
Double32_t&operator[](Int_t i)
Double32_tOrto3Column(Int_t col, Int_t ref)
voidOrtoNorm3()
Double32_tOrtoNorm3Column(Int_t col, Int_t ref)
voidPrint() const
Double32_t*PtrBaseVec(Int_t b)
const Double32_t*PtrBaseVec(Int_t b) const
Double32_t*PtrBaseVecX()
const Double32_t*PtrBaseVecX() const
Double32_t*PtrBaseVecY()
const Double32_t*PtrBaseVecY() const
Double32_t*PtrBaseVecZ()
const Double32_t*PtrBaseVecZ() const
Double32_t*PtrPos()
HPoint<Double32_t>Rotate(const HPoint<Double32_t>& v) const
voidRotate(const HTrans<Double32_t>& a, Int_t i1, Int_t i2, Double32_t amount)
voidRotateBackVec3(const Double32_t* in, Double32_t* out) const
voidRotateIP(HPoint<Double32_t>& v) const
voidRotateLF(Int_t i1, Int_t i2, Double32_t amount)
voidRotatePF(Int_t i1, Int_t i2, Double32_t amount)
voidRotateVec3(const Double32_t* in, Double32_t* out) const
voidRotateVec3IP(Double32_t* in) const
voidScale(Double32_t sx, Double32_t sy, Double32_t sz)
voidSetBaseVec(Int_t b, Float_t* x)
voidSetBaseVec(Int_t b, Double_t* x)
voidSetBaseVec(Int_t b, Double32_t x, Double32_t y, Double32_t 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<Double32_t>& t)
voidSetPos(Double32_t x, Double32_t y, Double32_t 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<Double32_t>& t)
voidSetupRotation(Int_t i, Int_t j, Double32_t f)
voidTranspose()
voidTransposeRotationPart()
voidUnitRot()
voidUnitTrans()
Double32_tUnscale()
voidUnscale(Double32_t& sx, Double32_t& sy, Double32_t& sz)

Data Members

protected:
Double32_tM[16]

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

HPoint& operator*=(const HTrans<Double32_t>& 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<Double32_t>& t)
void SetFromArray(const Float_t* arr)
void SetFromArray(const Double_t* arr)
void SetupRotation(Int_t i, Int_t j, Double32_t 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<Double32_t>& t)
void MultRight(const HTrans<Double32_t>& t)
void MultLeft3x3(const Double32_t* m)
void MultRight3x3(const Double32_t* m)
void MultLeft3x3transposed(const Double32_t* m)
void MultRight3x3transposed(const Double32_t* m)
void MoveLF(Int_t ai, Double32_t amount)
 Move & Rotate
void Move3LF(Double32_t x, Double32_t y, Double32_t z)
void RotateLF(Int_t i1, Int_t i2, Double32_t amount)
void MovePF(Int_t ai, Double32_t amount)
void Move3PF(Double32_t x, Double32_t y, Double32_t z)
void RotatePF(Int_t i1, Int_t i2, Double32_t amount)
void Move(const HTrans<Double32_t>& a, Int_t ai, Double32_t amount)
void Move3(const HTrans<Double32_t>& a, Double32_t x, Double32_t y, Double32_t z)
void Rotate(const HTrans<Double32_t>& a, Int_t i1, Int_t i2, Double32_t amount)
void SetBaseVec(Int_t b, Double32_t x, Double32_t y, Double32_t 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(Double32_t x, Double32_t y, Double32_t 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(Double32_t& x, Double32_t& y, Double32_t& 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(Double32_t sx, Double32_t sy, Double32_t sz)
 Scaling
void GetScale(Double32_t& sx, Double32_t& sy, Double32_t& sz) const
void Unscale(Double32_t& sx, Double32_t& sy, Double32_t& sz)
TT Unscale()
void MultiplyIP(HPoint<Double32_t>& v, Double32_t w = 1) const
 Operations on vectors
void RotateIP(HPoint<Double32_t>& v) const
HPoint<TT> Multiply(const HPoint<Double32_t>& v, Double32_t w = 1) const
HPoint<TT> Rotate(const HPoint<Double32_t>& v) const
void MultiplyVec3IP(Double32_t* in, Double32_t w) const
void MultiplyVec3(const Double32_t* in, Double32_t w, Double32_t* out) const
void RotateVec3IP(Double32_t* in) const
void RotateVec3(const Double32_t* in, Double32_t* out) const
void RotateBackVec3(const Double32_t* in, Double32_t* out) const