PUBLIC

RigidTransC::RigidTransC(void) RigidTransC::RigidTransC(Vector3dC,QuarternC) RigidTransC::RigidTransC(Vector3dC,Vector3dC) RigidTransC::RigidTransC(Vector3dC,Vector3dC,double) RigidTransC::RigidTransC(Vector3dC,Matrix3d3C) RigidTransC::RigidTransC(const HomtmC &) RigidTransC::RigidTransC(const RigidTransC &) RigidTransC::operator=(const RigidTransC &) RigidTransC::~RigidTransC(void) RigidTransC::Set(Vector3dC,QuarternC) RigidTransC::Set(Vector3dC,Vector3dC,double) RigidTransC::Set(Vector3dC,Matrix3d3C) RigidTransC::GetRot(void) const RigidTransC::SetRot(QuarternC) RigidTransC::GetTrans(void) const RigidTransC::SetTrans(Vector3dC) RigidTransC::NormalizeQuart(void) RigidTransC::Transform(Vector3dC) const RigidTransC::NTransform(Vector3dC) const RigidTransC::InverseTransform(Vector3dC) RigidTransC::InverseNTransform(Vector3dC) RigidTransC::Inverse(void) const RigidTransC::ApplyRotOnly(QuarternC) RigidTransC::ApplyRotPivot(QuarternC,Vector3dC) RigidTransC::ApplyTranslate(Vector3dC) RigidTransC::ExportTrans(void) const RigidTransC::ExportAxTheta(void) const RigidTransC::ExportRotAngle(void) const RigidTransC::ExportRotAxis(void) const RigidTransC::ExportRotQuart(void) const RigidTransC::ExportRotMat(void) const RigidTransC::Print(void) RigidTransC::LongPrint(void) RigidTransC::operator*(const RigidTransC &,const RealT &) RigidTransC::operator+(const RigidTransC &,const RigidTransC &) RigidTransC::operator-(const RigidTransC &,const RigidTransC &) RigidTransC::Abs(void) RigidTransC::operator<<(ostream &,const RigidTransC &)

RigidTransC
include	"amma/RigidT.hh"
User Level:	Default
Library:	RigidT
Example:	aff_transf.cc
Section:	3D Surface.Rigid Body Transforms
In Scope:	std

Comments:
------------------------------------------------------------------------- ********** RigidTransC ************************************************ ------------------------------------------------------------------------- .LP A RigigTransC is a 3D Rigid body transformation comprising of a rotation followed by a translation. The order is very important. .LP A RigigTransC can also be thought of as a Pose, i.e. a position and orientation. .LP This library is based on an active scheme, i.e. there is one fixed coordinate system and the rotation and translation may be envisaged as acting ON an object. [ See CoordSysC for a passive scheme ] .LP

RigidTransC()

Null Constructor

RigidTransC(Vector3dC trans,QuarternC q)

Constructor

RigidTransC(Vector3dC trans,Vector3dC axtheta)

Constructor

RigidTransC(Vector3dC trans,Vector3dC axis,double theta)

Constructor

RigidTransC(Vector3dC trans,Matrix3d3C rotate)

Constructor

RigidTransC(const HomtmC & h)

Constructor; note possible problems near PI

RigidTransC(const RigidTransC & p)

Copy constructor

RigidTransC & operator=(const RigidTransC & p)

~RigidTransC()

Destructor Access ------

RigidTransC & Set(Vector3dC trans,QuarternC q)

Set as specified

RigidTransC & Set(Vector3dC trans,Vector3dC axis,double theta)

Set as specified

RigidTransC & Set(Vector3dC trans,Matrix3d3C rotate)

Set as specified

QuarternC GetRot(void) const

output the rotation as a quarternion

RigidTransC & SetRot(QuarternC q)

Set the rotation, leave trans unchanged

Vector3dC GetTrans(void) const

output the translation

RigidTransC & SetTrans(Vector3dC t)

Set the translation, leave rot unchanged General operations ------------------

void NormalizeQuart(void)

Make absolutely sure that the quarternion is valid with norm=1

Vector3dC Transform(Vector3dC v) const

applys rigid body transformation to v: v1=Rv +t

Vector3dC NTransform(Vector3dC n) const

applys rigid body transformation to a normal vector : n1=Rn, i.e. the vector is not translated

Vector3dC InverseTransform(Vector3dC v)

applys rigid body transformation to v: v1=R^-1 (v-T)t

Vector3dC InverseNTransform(Vector3dC n)

applys rigid body transformation to a normal vector : n1=R^-1 n, i.e. the vector is not translated

RigidTransC Inverse(void) const

Returns the inverse transform

RigidTransC & ApplyRotOnly(QuarternC q)

Apply the specified rotation only to the rot (not the trans)

RigidTransC & ApplyRotPivot(QuarternC q,Vector3dC pivot)

Apply the specified rotation around the specified pivot point

RigidTransC & ApplyTranslate(Vector3dC t)

Translate the RigidT by t Exporting ---------

Vector3dC ExportTrans() const

return translation

Vector3dC ExportAxTheta() const

return rot as a unit vector axis times theta in radians Possible problems for angles near PI, see Quartern.hh

double ExportRotAngle() const

Vector3dC ExportRotAxis() const

return rot as a unit vector axis around which rotated and the angle in radians, if Rotation matrix is identity return axis as (0,0,0) vector

QuarternC ExportRotQuart() const

return rotation as quarternion

Matrix3d3C ExportRotMat() const

return rotation as 3x3 rotation matrix

void Print()

simple printout

void LongPrint()

detailed printout

RigidTransC operator*(const RigidTransC & p1,const RealT & val)

returns trans[i] = p1.trans[i]*val (i=0..2) and rot[i] = p1.rot[i]*val (i=0..3)

RigidTransC operator+(const RigidTransC & p1,const RigidTransC & p2)

returns trans[i] = p1.trans[i] + p2.trans[i] (i=0..2) and rot[i] = p1.rot[i] + p2.rot[i] (i=0..3)

RigidTransC operator-(const RigidTransC & p1,const RigidTransC & p2)

returns trans[i] = p1.trans[i] - p2.trans[i] (i=0..2) and rot[i] = p1.rot[i] - p2.rot[i] (i=0..3)

RigidTransC Abs()

ostream & operator<<(ostream & outS,const RigidTransC & rt)

output stream operator