Classes
struct	AL::Math::Pose2D
	A pose in a 2-dimentional space. More...
struct	AL::Math::Position2D
	Create and play with a Position2D. More...
struct	AL::Math::Position3D
	Create and play with a Position3D. More...
struct	AL::Math::Position6D
	Create and play with a Position6D. More...
struct	AL::Math::PositionAndVelocity
	Create and play with a PositionAndVelocity. More...
struct	AL::Math::Quaternion
	Create and play with a Quaternion. More...
struct	AL::Math::Rotation
	A 3*3 rotation matrix. More...
struct	AL::Math::Rotation3D
	A Rotation3D give 3 composed angles in radians. More...
struct	AL::Math::Transform
	A homogenous transformation matrix. More...
struct	AL::Math::Velocity3D
	Create and play with a Velocity3D. More...
struct	AL::Math::Velocity6D
	Create and play with a Velocity6D. More...
Typedefs
typedef std::bitset< 6 >	AL::Math::AXIS_MASK
	Definition of an AXIS_MASK as a bit set.
Functions
std::ostream &	AL::Math::operator<< (std::ostream &pStream, const Pose2D &pPos)
	Overloading of operator << for Pose2D.
std::ostream &	AL::Math::operator<< (std::ostream &pStream, const Position2D &pPos)
	Overloading of operator << for Position2D.
std::ostream &	AL::Math::operator<< (std::ostream &pStream, const Position3D &pPos)
	Overloading of operator << for Position3D.
std::ostream &	AL::Math::operator<< (std::ostream &pStream, const Position6D &pPos)
	Overloading of operator << for Position6D.
std::ostream &	AL::Math::operator<< (std::ostream &pStream, const PositionAndVelocity &pPosVel)
	Overloading of operator << for PositionAndVelocity.
std::ostream &	AL::Math::operator<< (std::ostream &pStream, const Rotation &pRot)
	Overloading of operator << for Rotation.
std::ostream &	AL::Math::operator<< (std::ostream &pStream, const Rotation3D &pRot)
	Overloading of operator << for Rotation3D.
std::ostream &	AL::Math::operator<< (std::ostream &pStream, const Transform &pT)
	Overloading of operator << for Transform.
std::ostream &	AL::Math::operator<< (std::ostream &pStream, const TransformAndVelocity6D &pTV)
	Overloading of operator << for TransformAndVelocity6D.
std::ostream &	AL::Math::operator<< (std::ostream &pStream, const Velocity3D &pVel)
	Overloading of operator << for Velocity3D.
std::ostream &	AL::Math::operator<< (std::ostream &pStream, const Velocity6D &pVel)
	Overloading of operator << for Velocity6D.
std::string	AL::Math::toSpaceSeparated (const Position3D &pPos)
	Create a string of Position3D.
std::string	AL::Math::toSpaceSeparated (const Velocity6D &pVel)
	Create a string of Velocity6D.
std::string	AL::Math::toSpaceSeparated (const Transform &pT)
	Create a string of Transform.
std::string	AL::Math::toSpaceSeparated (const Position6D &pPos)
	Create a string of Position6D.
std::ostream &	AL::Math::operator<< (std::ostream &pStream, const Quaternion &pQua)
	Overloading of operator << for Quaternion.
float	AL::Math::distanceSquared (const Pose2D &pPos1, const Pose2D &pPos2)
	Compute the squared distance between two Pose2D.
float	AL::Math::distance (const Pose2D &pPos1, const Pose2D &pPos2)
	Compute the distance between two Pose2D.
Pose2D	AL::Math::pose2DInverse (const Pose2D &pPos)
	Compute the inverse of a Pose2D.
void	AL::Math::pose2DInverse (const Pose2D &pPos, Pose2D &pRes)
	Compute the inverse of a Pose2D.
float	AL::Math::distanceSquared (const Position2D &pPos1, const Position2D &pPos2)
	Compute the squared distance between two Position2D.
float	AL::Math::distance (const Position2D &pPos1, const Position2D &pPos2)
	Compute the distance between two Position2D :
float	AL::Math::norm (const Position2D &pPos)
	Compute the norm of a Position2D.
Position2D	AL::Math::normalize (const Position2D &pPos)
	Normalize a Position2D.
float	AL::Math::crossProduct (const Position2D &pPos1, const Position2D &pPos2)
	Compute the cross Product of two Position2D.
void	AL::Math::crossProduct (const Position2D &pPos1, const Position2D &pPos2, float &pRes)
	Compute the cross Product of two Position2D.
float	AL::Math::distanceSquared (const Position3D &pPos1, const Position3D &pPos2)
	Compute the squared distance between two Position3D:
float	AL::Math::distance (const Position3D &pPos1, const Position3D &pPos2)
	Compute the distance between two Position3D:
float	AL::Math::norm (const Position3D &pPos)
	Compute the norm of a Position3D:
Position3D	AL::Math::normalize (const Position3D &pPos)
	Normalize a Position3D:
float	AL::Math::distanceSquared (const Position6D &pPos1, const Position6D &pPos2)
	Compute the squared distance of translation part (x, y and z) between two Position6D:
float	AL::Math::distance (const Position6D &pPos1, const Position6D &pPos2)
	Compute the distance of translation part (x, y and z) between two Position6D:
float	AL::Math::norm (const Position6D &pPos)
	Compute the norm of a Position6D:
Position6D	AL::Math::normalize (const Position6D &pPos)
	Normalize a Position6D:
float	AL::Math::norm (const Quaternion &pQua)
	Compute the norm of a Quaternion:
Quaternion	AL::Math::normalize (const Quaternion &pQua)
	Normalize a Quaternion:
void	AL::Math::quaternionInverse (const Quaternion &pQua, Quaternion &pQuaOut)
	Return the quaternion inverse of the given Quaternion:
Quaternion	AL::Math::quaternionInverse (const Quaternion &pQua)
	Return the quaternion inverse of the given Quaternion.
Quaternion	AL::Math::quaternionFromAngleAndAxisRotation (const float pAngle, const float pAxisX, const float pAxisY, const float pAxisZ)
	Create a Quaternion initialized with explicit angle and axis rotation.
void	AL::Math::angleAndAxisRotationFromQuaternion (const Quaternion &pQuaternion, float &pAngle, float &pAxisX, float &pAxisY, float &pAxisZ)
	Compute angle and axis rotation from a Quaternion.
Rotation	AL::Math::transpose (const Rotation &pRot)
	Compute the transpose rotation of the one given in argument:
float	AL::Math::determinant (const Rotation &pRot)
	Compute the determinant of the given Rotation:
Rotation	AL::Math::rotationFromQuaternion (const float pA, const float pB, const float pC, const float pD)
	Creates a 3*3 Rotation Matrix from a normalized quaternion ( \|a + bi + cj + dk\| = 1).
Rotation	AL::Math::rotationFromAngleDirection (const float pAngle, const float pX, const float pY, const float pZ)
	Creates a 3*3 Rotation Matrix from a an angle and a normalized direction( \|pX, pY, pZ\| = 1).
void	AL::Math::applyRotation (const AL::Math::Rotation &pRot, float &pX, float &pY, float &pZ)
	Apply Rotation to a 3D point.
Rotation	AL::Math::rotationFromRotX (const float pRotX)
	Create a Rotation initialized with explicit rotation around x axis.
Rotation	AL::Math::rotationFromRotY (const float pRotY)
	Create a Rotation initialized with explicit rotation around y axis.
Rotation	AL::Math::rotationFromRotZ (const float pRotZ)
	Create a Rotation initialized with explicit rotation around z axis.
Rotation	AL::Math::rotationFrom3DRotation (const float &pWX, const float &pWY, const float &pWZ)
	Create a Rotation initialized with euler angle. Rot = fromRotZ(pWZ)fromRotY(pWY)fromRotX(pWX)
float	AL::Math::norm (const Rotation3D &pRot)
	Compute the norm of a Rotation3D:
void	AL::Math::transformPreMultiply (const Transform &pT, Transform &pTOut)
	pTOut = pT*pTOut
float	AL::Math::norm (const Transform &pT)
	Compute the norm translation part of the actual Transform:
void	AL::Math::transformToFloatVector (const Transform &pT, std::vector< float > &pTOut)
	Copy the Transform in a vector of float:
std::vector< float >	AL::Math::transformToFloatVector (const Transform &pT)
	Return the Transform in a vector of float:
float	AL::Math::determinant (const Transform &pT)
	Compute the determinant of rotation part of the given Transform:
float	AL::Math::determinant (const std::vector< float > &pFloats)
	Compute the determinant of rotation part of the given vector of floats:
void	AL::Math::transformInverse (const Transform &pT, Transform &pTOut)
	Return the transform inverse of the given Transform:
Transform	AL::Math::transformInverse (const Transform &pT)
	Return the transform inverse of the given Transform:
Transform	AL::Math::transformFromRotX (const float pRotX)
	Create a Transform initialize with explicit rotation around x axis:
Transform	AL::Math::transformFromRotY (const float pRotY)
	Create a Transform initialize with explicit rotation around y axis:
Transform	AL::Math::transformFromRotZ (const float pRotZ)
	Create a Transform initialize with explicit rotation around z axis:
Transform	AL::Math::transformFrom3DRotation (const float &pWX, const float &pWY, const float &pWZ)
	Create a Transform initialize with euler angle: H = fromRotZ(pWZ)fromRotY(pWY)fromRotX(pWX)
Transform	AL::Math::transformFromPosition (const float &pX, const float &pY, const float &pZ)
	Create a Transform initialize with explicit value for translation part:
Transform	AL::Math::transformFromPosition (const float &pX, const float &pY, const float &pZ, const float &pWX, const float &pWY, const float &pWZ)
	Create a Transform initialize with explicit value for translation part and euler angle:
void	AL::Math::transformInvertInPlace (Transform &pT)
	Inverse the given Transform in place:
Transform	AL::Math::pinv (const Transform &pT)
	Alternative name for inverse: return the transform inverse of the given Transform:
Transform	AL::Math::transformDiff (const Transform &pT1, const Transform &pT2)
	Compute the Transform between the actual Transform and the one give in argument result:
float	AL::Math::transformDistanceSquared (const Transform &pT1, const Transform &pT2)
	Compute the squared distance between the actual Transform and the one give in argument (translation part):
float	AL::Math::transformDistance (const Transform &pT1, const Transform &pT2)
	Compute the distance between the actual Transform and the one give in argument:
float	AL::Math::norm (const Velocity3D &pVel)
	Compute the norm of a Velocity3D:
Velocity3D	AL::Math::normalize (const Velocity3D &pVel)
	Normalize a Velocity3D:
float	AL::Math::norm (const Velocity6D &pVel)
	Compute the norm of a Velocity6D:
Velocity6D	AL::Math::normalize (const Velocity6D &pVel)
	Normalize a Velocity6D:

Detailed Description

Types classes provide many usefull defintion in robotics field such as homogenous transform matrix, 6D vector of velocty and so on.

Typedef Documentation

typedef std::bitset<6> AL::Math::AXIS_MASK

Definition of an AXIS_MASK as a bit set.

static const int AXIS_MASK_X = 1
static const int AXIS_MASK_Y = 2
static const int AXIS_MASK_XY = 3
static const int AXIS_MASK_Z = 4
static const int AXIS_MASK_WX = 8
static const int AXIS_MASK_WY = 16
static const int AXIS_MASK_WZ = 32
static const int AXIS_MASK_WYWZ = 48
static const int AXIS_MASK_ALL = 63
static const int AXIS_MASK_VEL = 7
static const int AXIS_MASK_ROT = 56
static const int AXIS_MASK_NONE = 0

Definition at line 34 of file alaxismask.h.

Function Documentation

void AL::Math::angleAndAxisRotationFromQuaternion	(	const Quaternion &	pQuaternion,
		float &	pAngle,
		float &	pAxisX,
		float &	pAxisY,
		float &	pAxisZ
	)

Compute angle and axis rotation from a Quaternion.

Parameters:

pQuaternion	the given quaternion
pAngle	the computed float value for angle in radian around axis rotation
pAxisX	the computed float value for x value of axis rotation
pAxisY	the computed float value for y value of axis rotation
pAxisZ	the computed float value for z value of axis rotation

void AL::Math::applyRotation	(	const AL::Math::Rotation &	pRot,
		float &	pX,
		float &	pY,
		float &	pZ
	)

Apply Rotation to a 3D point.

Parameters:

pRot	the given rotation
pX	the X position of the 3D point after rotation
pY	the Y position of the 3D point after rotation
pZ	the Z position of the 3D point after rotation

float AL::Math::crossProduct	(	const Position2D &	pPos1,
		const Position2D &	pPos2
	)

Compute the cross Product of two Position2D.

$pRes = (pPos1.x*pPos2.y - pPos1.y*pPos2.x)$

Parameters:

pPos1	the first Position2D
pPos2	the second Position2D

Returns:: the float cross product between the two Position2D

void AL::Math::crossProduct	(	const Position2D &	pPos1,
		const Position2D &	pPos2,
		float &	pRes
	)

Compute the cross Product of two Position2D.

$pRes = (pPos1.x*pPos2.y - pPos1.y*pPos2.x)$

Parameters:

pPos1	the first Position2D
pPos2	the second Position2D
pRes	the float cross product between the two Position2D

float AL::Math::determinant ( const Rotation & pRot )

Compute the determinant of the given Rotation:

$pRot.r_1c_1*pRot.r_2c_2*pRot.r_3c_3 + pRot.r_1c_2*pRot.r_2c_3*pRot.r_3c_1 + pRot.r_1c_3*pRot.r_2c_1*pRot.r_3c_2 - pRot.r_1c_1*pRot.r_2c_3*pRot.r_3c_2 - pRot.r_1c_2*pRot.r_2c_1*pRot.r_3c_3 - pRot.r_1c_3*pRot.r_2c_2*pRot.r_3c_1$

Parameters:

pRot	the given Rotation

Returns:: the float determinant of Rotation

float AL::Math::determinant ( const Transform & pT )

Compute the determinant of rotation part of the given Transform:

$pT.r_1c_1*pT.r_2c_2*pT.r_3c_3 + pT.r_1c_2*pT.r_2c_3*pT.r_3c_1 + pT.r_1c_3*pT.r_2c_1 * pT.r_3c_2 - pT.r_1c_1*pT.r_2c_3*pT.r_3c_2 - pT.r_1c_2*pT.r_2c_1*pT.r_3c_3 - pT.r_1c_3*pT.r_2c_2*pT.r_3c_1$

Parameters:

pT	the given Transform

Returns:: the float determinant of rotation Transform part

float AL::Math::determinant ( const std::vector< float > & pFloats )

Compute the determinant of rotation part of the given vector of floats:

$pT[0]*pT[5]*pT[10] + pT[1]*pT[6]*pT[8] + pT[2]*pT[4]*pT[9] - pT[0]*pT[6]*pT[9] - pT[1]*pT[4]*pT[10] - pT[2]*pT[5]*pT[8]$

Parameters:

pFloats the given vector of floats

Returns:: the float determinant of rotation Transform part

float AL::Math::distance	(	const Pose2D &	pPos1,
		const Pose2D &	pPos2
	)

Compute the distance between two Pose2D.

$\sqrt{(pPos1.x-pPos2.x)^2+(pPos1.y-pPos2.y)^2}$

Parameters:

pPos1	the first Pose2D
pPos2	the second Pose2D

Returns:: the float distance between the two Pose2D

float AL::Math::distance	(	const Position2D &	pPos1,
		const Position2D &	pPos2
	)

Compute the distance between two Position2D $(pPos1,pPos2)$ :

$\sqrt{(pPos1.x-pPos2.x)^2+(pPos1.y-pPos2.y)^2}$

Parameters:

pPos1	the first Position2D
pPos2	the second Position2D

Returns:: the float distance between the two Position2D

float AL::Math::distance	(	const Position6D &	pPos1,
		const Position6D &	pPos2
	)

Compute the distance of translation part (x, y and z) between two Position6D:

$\sqrt{(pPos1.x-pPos2.x)^2+(pPos1.y-pPos2.y)^2+(pPos1.z-pPos2.z)^2}$

Parameters:

pPos1	the first Position6D
pPos2	the second Position6D

Returns:: the float distance between the two Position6D

float AL::Math::distance	(	const Position3D &	pPos1,
		const Position3D &	pPos2
	)

Compute the distance between two Position3D:

$\sqrt{(pPos1.x-pPos2.x)^2+(pPos1.y-pPos2.y)^2+(pPos1.z-pPos2.z)^2}$

Parameters:

pPos1	the first Position3D
pPos2	the second Position3D

Returns:: the float distance between the two Position3D

float AL::Math::distanceSquared	(	const Pose2D &	pPos1,
		const Pose2D &	pPos2
	)

Compute the squared distance between two Pose2D.

$(pPos1.x-pPos2.x)^2+(pPos1.y-pPos2.y)^2$

Parameters:

pPos1	the first Pose2D
pPos2	the second Pose2D

Returns:: the float squared distance between the two Pose2D

float AL::Math::distanceSquared	(	const Position2D &	pPos1,
		const Position2D &	pPos2
	)

Compute the squared distance between two Position2D.

$(pPos1.x-pPos2.x)^2+(pPos1.y-pPos2.y)^2$

Parameters:

pPos1	the first Position2D
pPos2	the second Position2D

Returns:: the float squared distance between the two Position2D

float AL::Math::distanceSquared	(	const Position6D &	pPos1,
		const Position6D &	pPos2
	)

Compute the squared distance of translation part (x, y and z) between two Position6D:

$(pPos1.x-pPos2.x)^2+(pPos1.y-pPos2.y)^2+(pPos1.z-pPos2.z)^2$

Parameters:

pPos1	the first Position6D
pPos2	the second Position6D

Returns:: the float squared distance between the two Position6D

float AL::Math::distanceSquared	(	const Position3D &	pPos1,
		const Position3D &	pPos2
	)

Compute the squared distance between two Position3D:

$(pPos1.x-pPos2.x)^2+(pPos1.y-pPos2.y)^2+(pPos1.z-pPos2.z)^2$

Parameters:

pPos1	the first Position3D
pPos2	the second Position3D

Returns:: the float squared distance between the two Position3D

float AL::Math::norm ( const Rotation3D & pRot )

Compute the norm of a Rotation3D:

$\sqrt{pRot.wx^2 + pRot.wy^2 + pRot.wz^2}$

Parameters:

pRot	the given Rotation3D

Returns:: the float norm of the given Rotation3D

float AL::Math::norm ( const Quaternion & pQua )

Compute the norm of a Quaternion:

$\sqrt{pQua.w^2+pQua.x^2+pQua.y^2+pQua.z^2}$

Parameters:

pQua	the given Quaternion

Returns:: the float norm of the given Quaternion

float AL::Math::norm ( const Velocity3D & pVel )

Compute the norm of a Velocity3D:

$\sqrt{pVel.xd^2 + pVel.yd^2 + pVel.zd^2}$

Parameters:

pVel	the given Velocity3D

Returns:: the float norm of the given Velocity3D

float AL::Math::norm ( const Velocity6D & pVel )

Compute the norm of a Velocity6D:

$\sqrt{pVel.xd^2 + pVel.yd^2 + pVel.zd^2 + pVel.wxd^2 + pVel.wyd^2 + pVel.wzd^2}$

Parameters:

pVel	the given Velocity6D

Returns:: the float norm of the given Velocity6D

float AL::Math::norm ( const Position2D & pPos )

Compute the norm of a Position2D.

$\sqrt{(pPos.x)^2+(pPos.y)^2}$

Parameters:

pPos	the given Position2D

Returns:: the float norm of the given Position2D

float AL::Math::norm ( const Position6D & pPos )

Compute the norm of a Position6D:

$\sqrt{pPos.x^2 + pPos.y^2 + pPos.z^2 + pPos.wx^2 + pPos.wy^2 + pPos.wz^2}$

Parameters:

pPos	the given Position6D

Returns:: the float norm of the given Position6D

float AL::Math::norm ( const Position3D & pPos )

Compute the norm of a Position3D:

$\sqrt{pPos.x^2+pPos.y^2+pPos.z^2}$

Parameters:

pPos	the given Position3D

Returns:: the float norm of the given Position3D

float AL::Math::norm ( const Transform & pT )

Compute the norm translation part of the actual Transform:

$\sqrt{pT.r_1c_4^2+pT.r_2c_4^2+pT.r_3c_4^2}$

Parameters:

pT	the given Transform

Returns:: the float norm of the given Transform

Quaternion AL::Math::normalize ( const Quaternion & pQua )

Normalize a Quaternion:

$pRes = \frac{pQua}{norm(pQua)}$

Parameters:

pQua	the given Quaternion

Returns:: the given Quaternion normalized

Velocity3D AL::Math::normalize ( const Velocity3D & pVel )

Normalize a Velocity3D:

$pRes = \frac{pVel}{norm(pVel)}$

Parameters:

pVel	the given Velocity3D

Returns:: the given Velocity3D normalized

Velocity6D AL::Math::normalize ( const Velocity6D & pVel )

Normalize a Velocity6D:

$pRes = \frac{pVel}{norm(pVel)}$

Parameters:

pVel	the given Velocity6D

Returns:: the given Velocity6D normalized

Position2D AL::Math::normalize ( const Position2D & pPos )

Normalize a Position2D.

$pRes = \frac{pPos}{norm(pPos)}$

Parameters:

pPos	the given Position2D

Returns:: the given Position2D normalized

Position6D AL::Math::normalize ( const Position6D & pPos )

Normalize a Position6D:

$pRes = \frac{pPos}{norm(pPos)}$

Parameters:

pPos	the given Position6D

Returns:: the given Position6D normalized

Position3D AL::Math::normalize ( const Position3D & pPos )

Normalize a Position3D:

$pRes = \frac{pPos}{norm(pPos)}$

Parameters:

pPos	the given Position3D

Returns:: the given Position3D normalized

std::ostream& AL::Math::operator<<	(	std::ostream &	pStream,
		const Pose2D &	pPos
	)

Overloading of operator << for Pose2D.

Parameters:

pStream	the given ostream
pPos	the given Pose2D

Returns:: the Pose2D print

std::ostream& AL::Math::operator<<	(	std::ostream &	pStream,
		const Position2D &	pPos
	)

Overloading of operator << for Position2D.

Parameters:

pStream	the given ostream
pPos	the given Position2D

Returns:: the Position2D print

std::ostream& AL::Math::operator<<	(	std::ostream &	pStream,
		const Position3D &	pPos
	)

Overloading of operator << for Position3D.

Parameters:

pStream	the given ostream
pPos	the given Position3D

Returns:: the Position3D print

std::ostream& AL::Math::operator<<	(	std::ostream &	pStream,
		const Position6D &	pPos
	)

Overloading of operator << for Position6D.

Parameters:

pStream	the given ostream
pPos	the given Position6D

Returns:: the Position6D print

std::ostream& AL::Math::operator<<	(	std::ostream &	pStream,
		const PositionAndVelocity &	pPosVel
	)

Overloading of operator << for PositionAndVelocity.

Parameters:

pStream	the given ostream
pPosVel	the given PositionAndVelocity

Returns:: the PositionAndVelocity print

std::ostream& AL::Math::operator<<	(	std::ostream &	pStream,
		const Rotation &	pRot
	)

Overloading of operator << for Rotation.

Parameters:

pStream	the given ostream
pRot	the given Rotation

Returns:: the Rotation print

std::ostream& AL::Math::operator<<	(	std::ostream &	pStream,
		const Rotation3D &	pRot
	)

Overloading of operator << for Rotation3D.

Parameters:

pStream	the given ostream
pRot	the given Rotation3D

Returns:: the Rotation3D print

std::ostream& AL::Math::operator<<	(	std::ostream &	pStream,
		const Transform &	pT
	)

Overloading of operator << for Transform.

Parameters:

pStream	the given ostream
pT	the given Transform

Returns:: the Transform print

std::ostream& AL::Math::operator<<	(	std::ostream &	pStream,
		const TransformAndVelocity6D &	pTV
	)

Overloading of operator << for TransformAndVelocity6D.

Parameters:

pStream	the given ostream
pTV	the given TransformAndVelocity6D

Returns:: the TransformAndVelocity6D print

std::ostream& AL::Math::operator<<	(	std::ostream &	pStream,
		const Velocity3D &	pVel
	)

Overloading of operator << for Velocity3D.

Parameters:

pStream	the given ostream
pVel	the given Velocity3D

Returns:: the Velocity3D print

std::ostream& AL::Math::operator<<	(	std::ostream &	pStream,
		const Velocity6D &	pVel
	)

Overloading of operator << for Velocity6D.

Parameters:

pStream	the given ostream
pVel	the given Velocity6D

Returns:: the Velocity6D print

std::ostream& AL::Math::operator<<	(	std::ostream &	pStream,
		const Quaternion &	pQua
	)

Overloading of operator << for Quaternion.

Parameters:

pStream	the given ostream
pPos	the given Quaternion

Returns:: the Quaternion print

Transform AL::Math::pinv ( const Transform & pT )

Alternative name for inverse: return the transform inverse of the given Transform:

$pT = \left[\begin{array}{cc} R & r \\ 0_{31} & 1 \end{array}\right]$ $pTOut = \left[\begin{array}{cc} R^t & (-R^t*r) \\ 0_{31} & 1 \end{array}\right]$

Parameters:

pT	the given Transform

Pose2D AL::Math::pose2DInverse ( const Pose2D & pPos )

Compute the inverse of a Pose2D.

Parameters:

pPos	the initial Pose2D

Returns:: the inverse Pose2D

void AL::Math::pose2DInverse	(	const Pose2D &	pPos,
		Pose2D &	pRes
	)

Compute the inverse of a Pose2D.

Parameters:

pPos	the initial Pose2D
pRes	the inverse Pose2D

Quaternion AL::Math::quaternionFromAngleAndAxisRotation	(	const float	pAngle,
		const float	pAxisX,
		const float	pAxisY,
		const float	pAxisZ
	)

Create a Quaternion initialized with explicit angle and axis rotation.

Parameters:

pAngle	the float value for angle in radian around axis rotation
pAxisX	the float value for x value of axis rotation
pAxisY	the float value for y value of axis rotation
pAxisZ	the float value for z value of axis rotation

Returns:: the Quaternion

void AL::Math::quaternionInverse	(	const Quaternion &	pQua,
		Quaternion &	pQuaOut
	)

Return the quaternion inverse of the given Quaternion:

Parameters:

pQua	the given Quaternion
pQuaOut	the inverse of the given Quaternion

Quaternion AL::Math::quaternionInverse ( const Quaternion & pQua )

Return the quaternion inverse of the given Quaternion.

Parameters:

pQua	the given Quaternion

Returns:: the Quaternion inverse

Rotation AL::Math::rotationFrom3DRotation	(	const float &	pWX,
		const float &	pWY,
		const float &	pWZ
	)

Create a Rotation initialized with euler angle. Rot = fromRotZ(pWZ)*fromRotY(pWY)*fromRotX(pWX)

Parameters:

pWX	the float value for euler angle x in radian
pWY	the float value for euler angle y in radian
pWZ	the float value for euler angle z in radian

Returns:: the Rotation matrix

Rotation AL::Math::rotationFromAngleDirection	(	const float	pAngle,
		const float	pX,
		const float	pY,
		const float	pZ
	)

Creates a 3*3 Rotation Matrix from a an angle and a normalized direction( |pX, pY, pZ| = 1).

Parameters:

pAngle	the float value of angle in radian
pX	the X direction of the vector of the rotation
pY	the Y direction of the vector of the rotation
pZ	the Z direction of the vector of the rotation

Returns:: the Rotation matrix

Rotation AL::Math::rotationFromQuaternion	(	const float	pA,
		const float	pB,
		const float	pC,
		const float	pD
	)

Creates a 3*3 Rotation Matrix from a normalized quaternion ( |a + bi + cj + dk| = 1).

Parameters:

pA	Coefficient a of the normalized quaternion
pB	Coefficient b of the normalized quaternion
pC	Coefficient c of the normalized quaternion
pD	Coefficient d of the normalized quaternion

Returns:: the Rotation matrix

Rotation AL::Math::rotationFromRotX ( const float pRotX )

Create a Rotation initialized with explicit rotation around x axis.

$pRot = \left[\begin{array}{cccc} 1.0 & 0.0 & 0.0 \\ 0.0 & cos(pRotX) & -sin(pRotX) \\ 0.0 & sin(pRotX) & cos(pRotX) \end{array}\right]$

Parameters:

pRotX the float value for angle rotation in radian around x axis

Returns:: the Rotation matrix

Rotation AL::Math::rotationFromRotY ( const float pRotY )

Create a Rotation initialized with explicit rotation around y axis.

$pT = \left[\begin{array}{cccc} cos(pRotY) & 0.0 & sin(pRotY) \\ 0.0 & 1.0 & 0.0 \\ -sin(pRotY) & 0.0 & cos(pRotY) \end{array}\right]$

Parameters:

pRotY the float value for angle rotation in radian around y axis

Returns:: the Rotation matrix

Rotation AL::Math::rotationFromRotZ ( const float pRotZ )

Create a Rotation initialized with explicit rotation around z axis.

$pT = \left[\begin{array}{cccc} cos(pRotZ) & -sin(pRotZ) & 0.0 \\ sin(pRotZ) & cos(pRotZ) & 0.0 \\ 0.0 & 0.0 & 1.0 \end{array}\right]$

Parameters:

pRotZ the float value for angle rotation in radian around z axis

Returns:: the Rotation matrix

std::string AL::Math::toSpaceSeparated ( const Position3D & pPos )

Create a string of Position3D.

Parameters:

pPos	the given Position3D

Returns:: the Velocity6D string

std::string AL::Math::toSpaceSeparated ( const Velocity6D & pVel )

Create a string of Velocity6D.

Parameters:

pVel	the given Velocity6D

Returns:: the Velocity6D string

std::string AL::Math::toSpaceSeparated ( const Transform & pT )

Create a string of Transform.

Parameters:

pT	the given Transform

Returns:: the Transform string

std::string AL::Math::toSpaceSeparated ( const Position6D & pPos )

Create a string of Position6D.

Parameters:

pPos	the given Position6D

Returns:: the Position6D string

Transform AL::Math::transformDiff	(	const Transform &	pT1,
		const Transform &	pT2
	)

Compute the Transform between the actual Transform and the one give in argument result:

inverse(pT1)*pT2

Parameters:

pT1	the first transform
pT2	the second transform

Returns:: the Transform

float AL::Math::transformDistance	(	const Transform &	pT1,
		const Transform &	pT2
	)

Compute the distance between the actual Transform and the one give in argument:

$\sqrt{(pT1.r_1c_4-pT2.r_1c_4)^2+(pT1.r_2c_4-pT2.r_2c_4)^2+(pT1.r_3c_4-pT2.r_3c_4)^2}$

Parameters:

pT1	the first Transform
pT2	the second Transform

Returns:: the float distance between the two Transform

float AL::Math::transformDistanceSquared	(	const Transform &	pT1,
		const Transform &	pT2
	)

Compute the squared distance between the actual Transform and the one give in argument (translation part):

$(pT1.r_1c_4-pT2.r_1c_4)^2 +(pT1.r_2c_4-pT2.r_2c_4)^2+(pT1.r_3c_4-pT2.r_3c_4)^2$

Parameters:

pT1	the first Transform
pT2	the second Transform

Returns:: the float squared distance between the two Transform: translation part

Transform AL::Math::transformFrom3DRotation	(	const float &	pWX,
		const float &	pWY,
		const float &	pWZ
	)

Create a Transform initialize with euler angle: H = fromRotZ(pWZ)*fromRotY(pWY)*fromRotX(pWX)

Parameters:

pWX	the float value for euler angle x in radian
pWY	the float value for euler angle y in radian
pWZ	the float value for euler angle z in radian

Returns:: the Transform

Transform AL::Math::transformFromPosition	(	const float &	pX,
		const float &	pY,
		const float &	pZ
	)

Create a Transform initialize with explicit value for translation part:

$pTOut = \left[\begin{array}{cccc} 1.0 & 0.0 & 0.0 & pX \\ 0.0 & 1.0 & 0.0 & pY \\ 0.0 & 0.0 & 1.0 & pZ \\ 0.0 & 0.0 & 0.0 & 1.0 \end{array}\right]$

Parameters:

pX	the float value for translation axis x in meter (r1_c4)
pY	the float value for translation axis y in meter (r2_c4)
pZ	the float value for translation axis z in meter (r3_c4)

Returns:: the Transform

Transform AL::Math::transformFromPosition	(	const float &	pX,
		const float &	pY,
		const float &	pZ,
		const float &	pWX,
		const float &	pWY,
		const float &	pWZ
	)

Create a Transform initialize with explicit value for translation part and euler angle:

H = fromRotZ(pWZ)*fromRotY(pWY)*fromRotX(pWX)

H.r1_c4 = pX

H.r2_c4 = pY

H.r3_c4 = pZ

Parameters:

pX	the float value for translation axis x in meter (r1_c4)
pY	the float value for translation axis y in meter (r2_c4)
pZ	the float value for translation axis z in meter (r3_c4)
pWX	the float value for euler angle x in radian
pWY	the float value for euler angle y in radian
pWZ	the float value for euler angle z in radian

Returns:: the Transform

Transform AL::Math::transformFromRotX ( const float pRotX )

Create a Transform initialize with explicit rotation around x axis:

$pTOut = \left[\begin{array}{cccc} 1.0 & 0.0 & 0.0 & 0.0 \\ 0.0 & cos(pRotX) & -sin(pRotX) & 0.0 \\ 0.0 & sin(pRotX) & cos(pRotX) & 0.0 \\ 0.0 & 0.0 & 0.0 & 1.0 \end{array}\right]$

Parameters:

pRotX the float value for angle rotation in radian around x axis

Returns:: the Transform

Transform AL::Math::transformFromRotY ( const float pRotY )

Create a Transform initialize with explicit rotation around y axis:

$pTOut = \left[\begin{array}{cccc} cos(pRotY) & 0.0 & sin(pRotY) & 0.0 \\ 0.0 & 1.0 & 0.0 & 0.0 \\ -sin(pRotY) & 0.0 & cos(pRotY) & 0.0 \\ 0.0 & 0.0 & 0.0 & 1.0 \end{array}\right]$

Parameters:

pRotY the float value for angle rotation in radian around y axis

Returns:: the Transform

Transform AL::Math::transformFromRotZ ( const float pRotZ )

Create a Transform initialize with explicit rotation around z axis:

$pTOut = \left[\begin{array}{cccc} cos(pRotZ) & -sin(pRotZ) & 0.0 & 0.0 \\ sin(pRotZ) & cos(pRotZ) & 0.0 & 0.0 \\ 0.0 & 0.0 & 1.0 & 0.0 \\ 0.0 & 0.0 & 0.0 & 1.0 \end{array}\right]$

Parameters:

pRotZ the float value for angle rotation in radian around z axis

Returns:: the Transform

void AL::Math::transformInverse	(	const Transform &	pT,
		Transform &	pTOut
	)

Return the transform inverse of the given Transform:

$pT = \left[\begin{array}{cc} R & r \\ 0_{31} & 1 \end{array}\right]$ $pTOut = \left[\begin{array}{cc} R^t & (-R^t*r) \\ 0_{31} & 1 \end{array}\right]$

Parameters:

pT	the given Transform
pTOut	the inverse of the given Transform

Transform AL::Math::transformInverse ( const Transform & pT )

Return the transform inverse of the given Transform:

$pT = \left[\begin{array}{cc} R & r \\ 0_{31} & 1 \end{array}\right]$ $pTOut = \left[\begin{array}{cc} R^t & (-R^t*r) \\ 0_{31} & 1 \end{array}\right]$

Parameters:

pT	the given Transform

Returns:: the Transform inverse

void AL::Math::transformInvertInPlace ( Transform & pT )

Inverse the given Transform in place:

Parameters:

pT	the given Transform

void AL::Math::transformPreMultiply	(	const Transform &	pT,
		Transform &	pTOut
	)

pTOut = pT*pTOut

Parameters:

pT	the first constant Transform
pTOut	the second modified Transform

void AL::Math::transformToFloatVector	(	const Transform &	pT,
		std::vector< float > &	pTOut
	)

Copy the Transform in a vector of float:

$\begin{array}{cccc} [r_1c_1, & r_1c_2, & r_1c_3, & r_1c_4, \\ r_2c_1, & r_2c_2, & r_2c_3, & r_2c_4, \\ r_3c_1, & r_3c_2, & r_3c_3, & r_3c_4, \\ 0.0, & 0.0, & 0.0, & 1.0] \end{array}$

Parameters:

pT	the given Transform
pTOut	the vector of float update to given transform value

std::vector<float> AL::Math::transformToFloatVector ( const Transform & pT )

Return the Transform in a vector of float:

$\begin{array}{cccc} [r_1c_1, & r_1c_2, & r_1c_3, & r_1c_4, \\ r_2c_1, & r_2c_2, & r_2c_3, & r_2c_4, \\ r_3c_1, & r_3c_2, & r_3c_3, & r_3c_4, \\ 0.0, & 0.0, & 0.0, & 1.0] \end{array}$

Parameters:

pT	the given Transform

Returns:: the vector of float update to given transform value

Rotation AL::Math::transpose ( const Rotation & pRot )

Compute the transpose rotation of the one given in argument:

Parameters:

pRot	the rotation matrix

Returns:: the rotation transposed

Classes

Typedefs

Functions

Detailed Description

Typedef Documentation

Function Documentation