ROOT logo
Gled » GLEDCORE » ZTrans

class ZTrans: public TObject

 ZTrans

 ZTrans is a 4x4 transformation matrix for homogeneous coordinates
 stored internaly in a column-major order to allow direct usage by
 GL. The element type is Double32_t as statically the floats would
 be precise enough but continuous operations on the matrix must
 retain precision of column vectors.

 Cartan angles in mA[1-3] (+z, -y, +x) are stored for backward
 compatibility and will probably be removed soon.

 Direct  element access (first two should be used with care):
 operator[i]    direct access to elements,   i:0->15
 CM(i,j)        element 4*j + i;           i,j:0->3    { CM ~ c-matrix }
 operator(i,j)  element 4*(j-1) + i - 1    i,j:1->4

 Column-vector access:
 USet Get/SetBaseVec(), Get/SetPos() and Arr[XYZT]() methods.

 For all methods taking the matrix indices:
 1->X, 2->Y, 3->Z; 4->Position (if applicable). 0 reserved for time.

 Shorthands in method-names:
 LF ~ LocalFrame; PF ~ ParentFrame; IP ~ InPlace

Function Members (Methods)

public:
ZTrans()
ZTrans(const ZTrans& z)
ZTrans(const ZNode* n)
ZTrans(const Double_t* arr)
ZTrans(const Float_t* arr)
virtual~ZTrans()
voidTObject::AbstractMethod(const char* method) const
virtual voidTObject::AppendPad(Option_t* option = "")
Double_t*Array()
const Double_t*Array() const
Double_t*ArrT()
const Double_t*ArrT() const
Double_t*ArrX()
const Double_t*ArrX() const
Double_t*ArrY()
const Double_t*ArrY() const
Double_t*ArrZ()
const Double_t*ArrZ() const
virtual voidTObject::Browse(TBrowser* b)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
Double_tCM(Int_t i, Int_t j) const
Double_t&CM(Int_t i, Int_t j)
virtual Int_tTObject::Compare(const TObject* obj) const
Bool_tCompareAngles(Float_t a1, Float_t a2, Float_t a3) const
virtual voidTObject::Copy(TObject& object) const
virtual voidTObject::Delete(Option_t* option = "")MENU
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
TVector3GetBaseVec(Int_t b) const
voidGetBaseVec(Int_t b, TVector3& v) const
voidGetBaseVec(Int_t b, Double_t* x) const
voidGetBaseVec(Int_t b, Float_t* x) const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual const char*TObject::GetIconName() const
virtual const char*TObject::GetName() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
TVector3GetPos() const
voidGetPos(Double_t* x) const
voidGetPos(Float_t* x) const
voidGetPos(TVector3& v) const
voidGetPos(Double_t& x, Double_t& y, Double_t& z) const
voidGetRotAngles(Float_t* x) const
voidGetScale(Double_t& sx, Double_t& sy, Double_t& sz) const
virtual const char*TObject::GetTitle() const
virtual UInt_tTObject::GetUniqueID() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() constMENU
Double_tInvert()
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTObject::IsSortable() const
Bool_tTObject::IsZombie() const
virtual voidTObject::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
voidMove(const ZTrans& a, Int_t ai, Double_t amount)
voidMove3(const ZTrans& a, Double_t x, Double_t y, Double_t z)
voidMove3LF(Double_t x, Double_t y, Double_t z)
voidMove3PF(Double_t x, Double_t y, Double_t z)
voidMoveLF(Int_t ai, Double_t amount)
voidMovePF(Int_t ai, Double_t amount)
TVector3Multiply(const TVector3& v, Double_t w = 1) const
voidMultiplyIP(TVector3& v, Double_t w = 1) const
voidMultLeft(const ZTrans& t)
voidMultRight(const ZTrans& t)
Double_tNorm3Column(Int_t col)
virtual Bool_tTObject::Notify()
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
Double_toperator()(Int_t i, Int_t j) const
Double_t&operator()(Int_t i, Int_t j)
ZTransoperator*(const ZTrans& t)
voidoperator*=(const ZTrans& t)
ZTrans&operator=(const ZTrans& t)
Double_toperator[](Int_t i) const
Double_t&operator[](Int_t i)
Double_tOrto3Column(Int_t col, Int_t ref)
voidOrtoNorm3()
Double_tOrtoNorm3Column(Int_t col, Int_t ref)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidPrint(Option_t* option = "") const
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
TVector3Rotate(const TVector3& v) const
voidRotate(const ZTrans& a, Int_t i1, Int_t i2, Double_t amount)
voidRotateIP(TVector3& v) const
voidRotateLF(Int_t i1, Int_t i2, Double_t amount)
voidRotatePF(Int_t i1, Int_t i2, Double_t amount)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
voidScale(Double_t sx, Double_t sy, Double_t sz)
voidSetBaseVec(Int_t b, const TVector3& v)
voidSetBaseVec(Int_t b, const Double_t* x)
voidSetBaseVec(Int_t b, const Float_t* x)
voidSetBaseVec(Int_t b, Double_t x, Double_t y, Double_t z)
voidSetBaseVecViaCross(Int_t i)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetFromArray(const Double_t* arr)
voidSetFromArray(const Float_t* arr)
static voidTObject::SetObjectStat(Bool_t stat)
voidSetPos(const Double_t* x)
voidSetPos(const Float_t* x)
voidSetPos(const ZTrans& t)
voidSetPos(Double_t x, Double_t y, Double_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 ZTrans& t)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidSetupRotation(Int_t i, Int_t j, Double_t f)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
voidTransposeRotationPart()
voidUnitRot()
voidUnitTrans()
Double_tUnscale()
voidUnscale(Double_t& sx, Double_t& sy, Double_t& sz)
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTObject::MakeZombie()

Data Members

protected:
Double32_tM[16]
Bool_tbAsOK!
Float_tmA1!
Float_tmA2!
Float_tmA3!

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

ZTrans()
{ UnitTrans(); }
ZTrans(const ZTrans& z)
{ *this = z; }
ZTrans(const ZNode* n)
{ *this = n->RefTrans(); }
ZTrans(const Double_t arr[16])
{ SetFromArray(arr); }
ZTrans(const Float_t arr[16])
{ SetFromArray(arr); }
void UnitTrans()
void UnitRot()
void SetTrans(const ZTrans& t)
void SetFromArray(const Double_t arr[16])
void SetFromArray(const Float_t arr[16])
void SetupRotation(Int_t i, Int_t j, Double_t f)
 Setup the matrix as an elementary rotation.
 Optimized versions of left/right multiplication with an elementary
 rotation matrix are implemented in RotatePF/RotateLF.
 Expects identity matrix.
void MultLeft(const ZTrans& t)
void MultRight(const ZTrans& t)
ZTrans operator*(const ZTrans& t)
void TransposeRotationPart()
void MoveLF(Int_t ai, Double_t amount)
void Move3LF(Double_t x, Double_t y, Double_t z)
void RotateLF(Int_t i1, Int_t i2, Double_t amount)
 Rotate in local frame. Does optimised version of MultRight.
void MovePF(Int_t ai, Double_t amount)
void Move3PF(Double_t x, Double_t y, Double_t z)
void RotatePF(Int_t i1, Int_t i2, Double_t amount)
 Rotate in parent frame. Does optimised version of MultLeft.
void Move(const ZTrans& a, Int_t ai, Double_t amount)
void Move3(const ZTrans& a, Double_t x, Double_t y, Double_t z)
void Rotate(const ZTrans& a, Int_t i1, Int_t i2, Double_t amount)
void SetRotByAngles(Float_t a1, Float_t a2, Float_t a3)
 Sets Rotation part as given by angles:
 a1 around z, -a2 around y, a3 around x
void SetRotByAnyAngles(Float_t a1, Float_t a2, Float_t a3, const Text_t* pat)
 Sets Rotation part as given by angles a1, a1, a3 and pattern pat.
 Pattern consists of "XxYyZz" characters.
 eg: x means rotate about x axis, X means rotate in negative direction
 xYz -> R_x(a3) * R_y(-a2) * R_z(a1); (standard Gled representation)
 Note that angles and pattern elements have inversed order!

 Implements Eulerian/Cardanian angles in a uniform way.
void GetRotAngles(Float_t* x) const
 Get Cardan rotation angles (pattern xYz above).
 This only works if no scaling has been applied.
Bool_t CompareAngles(Float_t a1, Float_t a2, Float_t a3) const
 Return true if angles currently used are the same as passed ones.
 This will most likely only work correctly if SetRotByAngles() was and
 will be used.
void Scale(Double_t sx, Double_t sy, Double_t sz)
void GetScale(Double_t& sx, Double_t& sy, Double_t& sz) const
void Unscale(Double_t& sx, Double_t& sy, Double_t& sz)
Double_t Unscale()
void MultiplyIP(TVector3& v, Double_t w = 1) const
TVector3 Multiply(const TVector3& v, Double_t w = 1) const
void RotateIP(TVector3& v) const
TVector3 Rotate(const TVector3& v) const
Double_t Norm3Column(Int_t col)
Double_t Orto3Column(Int_t col, Int_t ref)
Double_t OrtoNorm3Column(Int_t col, Int_t ref)
 Ortogonalize col wrt ref then normalize col.
 Returns dot-product.

 Assumption that both vectors are normalized and doing the calculation
 in a single step resulted in slow degradation of norms.
 The idea was ... since i know the projection on a future orthogonal vector
 i also know the length after subtraction: len = sqrt(1 - dp^2).
void OrtoNorm3()
void SetBaseVecViaCross(Int_t i)
Double_t Invert()
 Copied from ROOT's TMatrixFCramerInv.
void Streamer(TBuffer& b)
 Stream an object of class ZTrans.
void Print(Option_t* option = "") const
void SetBaseVec(Int_t b, Double_t x, Double_t y, Double_t z)
void SetBaseVec(Int_t b, const TVector3& v)
void SetBaseVec(Int_t b, const Double_t* x)
void SetBaseVec(Int_t b, const Float_t* x)
TVector3 GetBaseVec(Int_t b) const
{ return TVector3(&M[4*--b]); }
void GetBaseVec(Int_t b, TVector3& v)
void GetBaseVec(Int_t b, Double_t* x)
void GetBaseVec(Int_t b, Float_t* x)
void SetPos(Double_t x, Double_t y, Double_t z)
{ M[12] = x; M[13] = y; M[14] = z; }
void SetPos(const Double_t* x)
{ M[12] = x[0]; M[13] = x[1]; M[14] = x[2]; }
void SetPos(const Float_t* x)
{ M[12] = x[0]; M[13] = x[1]; M[14] = x[2]; }
void SetPos(const ZTrans& t)
void GetPos(Double_t& x, Double_t& y, Double_t& z) const
{ x = M[12]; y = M[13]; z = M[14]; }
void GetPos(Double_t* x)
{ x[0] = M[12]; x[1] = M[13]; x[2] = M[14]; }
void GetPos(Float_t* x)
{ x[0] = M[12]; x[1] = M[13]; x[2] = M[14]; }
void GetPos(TVector3& v)
{ v.SetXYZ(M[12], M[13], M[14]); }
TVector3 GetPos() const
{ return TVector3(M[12], M[13], M[14]); }
virtual ~ZTrans()
{}
ZTrans& operator=(const ZTrans& t)
{ SetTrans(t); return *this; }
void operator*=(const ZTrans& t)
{ MultRight(t); }
Double_t* Array()
 Element access
Double_t* ArrX()
Double_t* ArrY()
Double_t* ArrZ()
Double_t* ArrT()
Double_t operator[](Int_t i)
{ return M[i]; }
Double_t& operator[](Int_t i)
{ return M[i]; }
Double_t CM(Int_t i, Int_t j)
{ return M[4*j + i]; }
Double_t& CM(Int_t i, Int_t j)
{ return M[4*j + i]; }
Double_t operator()(Int_t i, Int_t j)
{ return M[4*j + i - 5]; }
Double_t& operator()(Int_t i, Int_t j)
{ return M[4*j + i - 5]; }