ROOT logo
Gled » VAR1 » HTrans<double>

class HTrans<double>

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

HTrans<Double_t>

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
static TClass*Class()
doubleCM(Int_t i, Int_t j) const
double&CM(Int_t i, Int_t j)
TVector3GetBaseVec(Int_t b) const
voidGetBaseVec(Int_t b, double* x) const
voidGetBaseVec(Int_t b, TVector3& v) const
TVector3GetPos() const
voidGetPos(double* x) const
voidGetPos(TVector3& v) const
voidGetPos(double& x, double& y, double& z) const
voidGetRotAngles(Float_t* x) const
voidGetScale(double& sx, double& sy, double& sz) const
doubleInvert()
doubleInvertWithoutRow4()
TClass*IsA() const
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)
TVector3Multiply(const TVector3& v, double w = 1) const
voidMultiplyIP(TVector3& 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>& t)
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(Option_t* option = "") 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()
TVector3Rotate(const TVector3& v) const
voidRotate(const HTrans<double>& a, Int_t i1, Int_t i2, double amount)
voidRotateBackVec3(const double* in, double* out) const
voidRotateIP(TVector3& 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, double* x)
voidSetBaseVec(Int_t b, const TVector3& v)
voidSetBaseVec(Int_t b, double x, double y, double z)
voidSetBaseVecViaCross(Int_t i)
voidSetPos(double* 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)
voidShowMembers(TMemberInspector& insp, char* parent)
voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
voidTranspose()
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 UnitTrans()
 General operations
void UnitRot()
void SetTrans(const HTrans<double>& t)
HTrans& operator=(const HTrans<double>& t)
{ SetTrans(t); return *this; }
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()
TT Invert()
TT InvertWithoutRow4()
void MultLeft(const HTrans<double>& t)
void MultRight(const HTrans<double>& t)
HTrans operator*(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)
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, 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, 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(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(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(double& x, double& y, double& 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(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(TVector3& v, double w = 1) const
 Operations on vectors
TVector3 Multiply(const TVector3& v, double w = 1) const
void RotateIP(TVector3& v) const
TVector3 Rotate(const TVector3& 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
void Print(Option_t* option = "") const