ROOT logo
Gled » GLEDCORE » HTrans<double>

class HTrans<double>

 HPoint -- a simple 3D point

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

HTrans<Double_t>, HTransD::TP

Function Members (Methods)

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

Data Members

protected:
doubleM[16]

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

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