KDL  1.4.0
Classes | Namespaces | Functions
frames.hpp File Reference
#include "utilities/kdl-config.h"
#include "utilities/utility.h"
#include "frames.inl"
Include dependency graph for frames.hpp:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  KDL::Vector
 A concrete implementation of a 3 dimensional vector class. More...
 
class  KDL::Rotation
 represents rotations in 3 dimensional space. More...
 
class  KDL::Frame
 represents a frame transformation in 3D space (rotation + translation) More...
 
class  KDL::Twist
 represents both translational and rotational velocities. More...
 
class  KDL::Wrench
 represents both translational and rotational acceleration. More...
 
class  KDL::Vector2
 2D version of Vector More...
 
class  KDL::Rotation2
 A 2D Rotation class, for conventions see Rotation. More...
 
class  KDL::Frame2
 A 2D frame class, for further documentation see the Frames class for methods with unchanged semantics. More...
 

Namespaces

 KDL
 

Functions

bool KDL::Equal (const Vector &a, const Vector &b, double eps=epsilon)
 
bool KDL::Equal (const Frame &a, const Frame &b, double eps=epsilon)
 
bool KDL::Equal (const Twist &a, const Twist &b, double eps=epsilon)
 
bool KDL::Equal (const Wrench &a, const Wrench &b, double eps=epsilon)
 
bool KDL::Equal (const Vector2 &a, const Vector2 &b, double eps=epsilon)
 
bool KDL::Equal (const Rotation2 &a, const Rotation2 &b, double eps=epsilon)
 
bool KDL::Equal (const Frame2 &a, const Frame2 &b, double eps=epsilon)
 
bool KDL::operator== (const Rotation &a, const Rotation &b)
 
bool KDL::Equal (const Rotation &a, const Rotation &b, double eps)
 
IMETHOD Vector KDL::diff (const Vector &p_w_a, const Vector &p_w_b, double dt=1)
 determines the difference of vector b with vector a. More...
 
IMETHOD Vector KDL::diff (const Rotation &R_a_b1, const Rotation &R_a_b2, double dt=1)
 determines the (scaled) rotation axis necessary to rotate from b1 to b2. More...
 
IMETHOD Twist KDL::diff (const Frame &F_a_b1, const Frame &F_a_b2, double dt=1)
 determines the rotation axis necessary to rotate the frame b1 to the same orientation as frame b2 and the vector necessary to translate the origin of b1 to the origin of b2, and stores the result in a Twist datastructure. More...
 
IMETHOD Twist KDL::diff (const Twist &a, const Twist &b, double dt=1)
 determines the difference between two twists i.e. More...
 
IMETHOD Wrench KDL::diff (const Wrench &W_a_p1, const Wrench &W_a_p2, double dt=1)
 determines the difference between two wrenches i.e. More...
 
IMETHOD Vector KDL::addDelta (const Vector &p_w_a, const Vector &p_w_da, double dt=1)
 adds vector da to vector a. More...
 
IMETHOD Rotation KDL::addDelta (const Rotation &R_w_a, const Vector &da_w, double dt=1)
 returns the rotation matrix resulting from the rotation of frame a by the axis and angle specified with da_w. More...
 
IMETHOD Frame KDL::addDelta (const Frame &F_w_a, const Twist &da_w, double dt=1)
 returns the frame resulting from the rotation of frame a by the axis and angle specified in da_w and the translation of the origin (also specified in da_w). More...
 
IMETHOD Twist KDL::addDelta (const Twist &a, const Twist &da, double dt=1)
 adds the twist da to the twist a. More...
 
IMETHOD Wrench KDL::addDelta (const Wrench &a, const Wrench &da, double dt=1)
 adds the wrench da to the wrench w. More...
 
IMETHOD Vector KDL::operator+ (const Vector &lhs, const Vector &rhs)
 
IMETHOD Vector KDL::operator- (const Vector &lhs, const Vector &rhs)
 
Vector KDL::operator* (const Vector &lhs, double rhs)
 
Vector KDL::operator* (double lhs, const Vector &rhs)
 
Vector KDL::operator/ (const Vector &lhs, double rhs)
 
Vector KDL::operator* (const Vector &lhs, const Vector &rhs)
 
Wrench KDL::operator* (const Wrench &lhs, double rhs)
 
Wrench KDL::operator* (double lhs, const Wrench &rhs)
 
Wrench KDL::operator/ (const Wrench &lhs, double rhs)
 
Wrench KDL::operator+ (const Wrench &lhs, const Wrench &rhs)
 
Wrench KDL::operator- (const Wrench &lhs, const Wrench &rhs)
 
Wrench KDL::operator- (const Wrench &arg)
 
Twist KDL::operator* (const Twist &lhs, double rhs)
 
Twist KDL::operator* (double lhs, const Twist &rhs)
 
Twist KDL::operator/ (const Twist &lhs, double rhs)
 
Twist KDL::operator+ (const Twist &lhs, const Twist &rhs)
 
Twist KDL::operator- (const Twist &lhs, const Twist &rhs)
 
Twist KDL::operator- (const Twist &arg)
 
Twist KDL::operator* (const Twist &lhs, const Twist &rhs)
 
Wrench KDL::operator* (const Twist &lhs, const Wrench &rhs)
 
Frame KDL::operator* (const Frame &lhs, const Frame &rhs)
 
Vector KDL::operator- (const Vector &arg)
 
IMETHOD Vector2 KDL::operator+ (const Vector2 &lhs, const Vector2 &rhs)
 
IMETHOD Vector2 KDL::operator- (const Vector2 &lhs, const Vector2 &rhs)
 
IMETHOD Vector2 KDL::operator* (const Vector2 &lhs, double rhs)
 
IMETHOD Vector2 KDL::operator* (double lhs, const Vector2 &rhs)
 
IMETHOD Vector2 KDL::operator/ (const Vector2 &lhs, double rhs)
 
IMETHOD Vector2 KDL::operator- (const Vector2 &arg)
 
IMETHOD Rotation2 KDL::operator* (const Rotation2 &lhs, const Rotation2 &rhs)
 
IMETHOD Frame2 KDL::operator* (const Frame2 &lhs, const Frame2 &rhs)
 
IMETHOD double KDL::dot (const Vector &lhs, const Vector &rhs)
 
IMETHOD double KDL::dot (const Twist &lhs, const Wrench &rhs)
 
IMETHOD double KDL::dot (const Wrench &rhs, const Twist &lhs)
 
IMETHOD void KDL::SetToZero (Vector &v)
 
IMETHOD void KDL::SetToZero (Twist &v)
 
IMETHOD void KDL::SetToZero (Wrench &v)
 
IMETHOD void KDL::SetToZero (Vector2 &v)
 
IMETHOD Rotation KDL::Rot (const Vector &axis_a_b)
 axis_a_b is a rotation vector, its norm is a rotation angle axis_a_b rotates the a frame towards the b frame. More...
 
IMETHOD void KDL::random (Vector &a)
 addDelta operator for displacement rotational velocity. More...
 
IMETHOD void KDL::random (Twist &a)
 
IMETHOD void KDL::random (Wrench &a)
 
IMETHOD void KDL::random (Rotation &R)
 
IMETHOD void KDL::random (Frame &F)
 
IMETHOD void KDL::posrandom (Vector &a)
 
IMETHOD void KDL::posrandom (Twist &a)
 
IMETHOD void KDL::posrandom (Wrench &a)
 
IMETHOD void KDL::posrandom (Rotation &R)
 
IMETHOD void KDL::posrandom (Frame &F)
 
IMETHOD bool KDL::operator== (const Frame &a, const Frame &b)
 
IMETHOD bool KDL::operator!= (const Frame &a, const Frame &b)
 
IMETHOD bool KDL::operator== (const Vector &a, const Vector &b)
 
IMETHOD bool KDL::operator!= (const Vector &a, const Vector &b)
 
IMETHOD bool KDL::operator== (const Twist &a, const Twist &b)
 
IMETHOD bool KDL::operator!= (const Twist &a, const Twist &b)
 
IMETHOD bool KDL::operator== (const Wrench &a, const Wrench &b)
 
IMETHOD bool KDL::operator!= (const Wrench &a, const Wrench &b)
 
IMETHOD bool KDL::operator!= (const Rotation &a, const Rotation &b)
 
IMETHOD bool KDL::operator== (const Vector2 &a, const Vector2 &b)
 
IMETHOD bool KDL::operator!= (const Vector2 &a, const Vector2 &b)
 

Detailed Description

Warning
Efficienty can be improved by writing p2 = A*(B*(C*p1))) instead of p2=A*B*C*p1
PROPOSED NAMING CONVENTION FOR FRAME-like OBJECTS
*      A naming convention of objects of the type defined in this file :
*          (1) Frame : F...
*              Rotation : R ...
*          (2) Twist    : T ...
*              Wrench   : W ...
*              Vector   : V ...
*      This prefix is followed by :
*      for category (1) :
*          F_A_B : w.r.t. frame A, frame B expressed
*          ( each column of F_A_B corresponds to an axis of B,
*            expressed w.r.t. frame A )
*          in mathematical convention :
*                   A
*         F_A_B ==    F
*                   B
*
*      for category (2) :
*          V_B   : a vector expressed w.r.t. frame B
*
*      This can also be prepended by a name :
*          e.g. : temporaryV_B
*
*      With this convention one can write :
*
*      F_A_B = F_B_A.Inverse();
*      F_A_C = F_A_B * F_B_C;
*      V_B   = F_B_C * V_C;    // both translation and rotation
*      V_B   = R_B_C * V_C;    // only rotation
* 
CONVENTIONS FOR WHEN USED WITH ROBOTS :
*       world : represents the frame ([1 0 0,0 1 0,0 0 1],[0 0 0]')
*       mp    : represents mounting plate of a robot
*               (i.e. everything before MP is constructed by robot manufacturer
*                    everything after MP is tool )
*       tf    : represents task frame of a robot
*               (i.e. frame in which motion and force control is expressed)
*       sf    : represents sensor frame of a robot
*               (i.e. frame at which the forces measured by the force sensor
*               are expressed )
*
*          Frame F_world_mp=...;
*          Frame F_mp_sf(..)
*          Frame F_mp_tf(,.)
*
*          Wrench are measured in sensor frame SF, so one could write :
*                Wrench_tf = F_mp_tf.Inverse()* ( F_mp_sf * Wrench_sf );
* 
CONVENTIONS REGARDING UNITS :
Any consistent series of units can be used, e.g. N,mm,Nmm,..mm/sec
Twist and Wrench transformations
3 different types of transformations do exist for the twists and wrenches.
*      1) Frame * Twist or Frame * Wrench :
*              this transforms both the velocity/force reference point
*             and the basis to which the twist/wrench are expressed.
*      2) Rotation * Twist or Rotation * Wrench :
*              this transforms the basis to which the twist/wrench are
*              expressed, but leaves the reference point intact.
*      3) Twist.RefPoint(v_base_AB) or Wrench.RefPoint(v_base_AB)
*              this transforms only the reference point. v is expressed
*              in the same base as the twist/wrench and points from the
*              old reference point to the new reference point.
* 
Spatial cross products
Let m be a 6D motion vector (Twist) and f be a 6D force vector (Wrench) attached to a rigid body moving with a certain velocity v (Twist). Then
*     1) m_dot = v cross m or Twist=Twist*Twist
*     2) f_dot = v cross f or Wrench=Twist*Wrench
*
Complexity
Sometimes the amount of work is given in the documentation e.g. 6M+3A means 6 multiplications and 3 additions.
Author
Erwin Aertbelien, Div. PMA, Dep. of Mech. Eng., K.U.Leuven