KDL Namespace Reference

Classes

class ConstraintMatrix

stores constraints and solves them. More...

class Error

Base class for errors generated by ORO_Geometry. More...

class Error_IO

class Error_BasicIO

class Error_BasicIO_File

class Error_BasicIO_Exp_Delim

class Error_BasicIO_Not_A_Space

class Error_BasicIO_Unexpected

class Error_BasicIO_ToBig

class Error_BasicIO_Not_Opened

class Error_FrameIO

class Error_Frame_Vector_Unexpected_id

class Error_Frame_Frame_Unexpected_id

class Error_Frame_Rotation_Unexpected_id

class Error_ChainIO

class Error_Chain_Unexpected_id

class Error_RedundancyIO

Error_Redundancy indicates an error that occured during solving for redundancy. More...

class Error_Redundancy_Illegal_Resolutiontype

class Error_Redundancy

class Error_Redundancy_Unavoidable

class Error_Redundancy_Low_Manip

class Error_MotionIO

class Error_MotionIO_Unexpected_MotProf

class Error_MotionIO_Unexpected_Traj

class Error_MotionPlanning

class Error_MotionPlanning_Circle_ToSmall

class Error_MotionPlanning_Circle_No_Plane

class Error_MotionPlanning_Incompatible

class Error_MotionPlanning_Not_Feasible

class Error_MotionPlanning_Not_Applicable

class Error_Integrator

Abstract subclass of all errors that can be thrown by Adaptive_Integrator. More...

class Error_Stepsize_Underflow

Error_Stepsize_Underflow is thrown if the stepsize becomes to small. More...

class Error_To_Many_Steps

Error_To_Many_Steps is thrown if the number of steps needed to integrate to the desired accuracy becomes to big. More...

class Error_Stepsize_To_Small

Error_Stepsize_To_Small is thrown if the stepsize becomes to small. More...

class Error_Criterium

class Error_Criterium_Unexpected_id

class Error_Limits

class Error_Limits_Unexpected_id

class Error_Not_Implemented

class VectorAcc

class RotationAcc

class FrameAcc

class TwistAcc

class Vector

A concrete implementation of a 3 dimensional vector class. More...

class Rotation

represents rotations in 3 dimensional space. More...

class Frame

represents a frame transformation in 3D space (rotation + translation) More...

class Twist

represents both translational and rotational velocities. More...

class Wrench

represents the combination of a force and a torque. More...

class Vector2

2D version of Vector More...

class Rotation2

A 2D Rotation class, for conventions see Rotation. More...

class Frame2

A 2D frame class, for further documentation see the Frames class for methods with unchanged semantics. More...

class VectorVel

class RotationVel

class FrameVel

class TwistVel

class FVector

FVector is a vectortype with following properties :

fully inlined code.
More...

class FVector2

FVector2 is a vectortype with following properties :

fully inlined code.
More...

class UnaryOp< OpInverse, FrameVel >

Inverse : derivative of R' is (derivative of R)' is [wx]', is [(-w)x]. More...

class BinaryOp< OpMult, FrameVel, FrameVel >

When designing this class, I realized some inconsistency between the routines fo transforming a twist (Frame::operator*(const Twist&) and these classes : Frame1 * Twist2 = velocity component of ( RVFrame2 * RVFrame1) (mind the order of the arguments . More...

class BinaryOp< OpMult, FrameVel, VectorVel >

class UnaryOp< OpInverse, RotationVel >

class BinaryOp< OpMult, RotationVel, RotationVel >

class BinaryOp< OpMult, RotationVel, VectorVel >

class BinaryOp< OpDiff, VectorVel, VectorVel >

operations defined : VECTOR = Diff(Vector,Vector) More...

class BinaryOp< OpDiff, RotationVel, RotationVel >

V* operations defined : VECTOR = Diff(Rotation,Rotation). More...

class BinaryOp< OpDiff, FrameVel, FrameVel >

operations defined : Twist = Diff(FrameVel,FrameVel) More...

class BinaryOp< OpDot, VectorVel, VectorVel >

class BinaryOp< OpMult, VectorVel, VectorVel >

class BinaryOp< OpAdd, VectorVel, VectorVel >

class BinaryOp< OpSub, VectorVel, VectorVel >

class UnaryOp< OpNegate, VectorVel >

class UnaryOp< OpNorm, VectorVel >

class BinaryOp< OpMult, VectorVel, doubleVel >

class BinaryOp< OpMult, doubleVel, VectorVel >

class UnaryOp< OpRotation, FrameVel >

class UnaryOp< OpOrigin, FrameVel >

class UnaryOp< OpUnitX, RotationVel >

class UnaryOp< OpUnitY, RotationVel >

class UnaryOp< OpUnitZ, RotationVel >

class UnaryOp< OpCoordX, VectorVel >

class UnaryOp< OpCoordY, VectorVel >

class UnaryOp< OpCoordZ, VectorVel >

class UnaryOp< OpNegate, TwistVel >

class BinaryOp< OpAdd, TwistVel, TwistVel >

class BinaryOp< OpSub, TwistVel, TwistVel >

class BinaryOp< OpMult, RotationVel, TwistVel >

class BinaryOp< OpMult, TwistVel, doubleVel >

class BinaryOp< OpMult, doubleVel, TwistVel >

class BinaryOp< OpRefPoint, TwistVel, VectorVel >

struct GeomTypeInfo

Used for Frame and Rotation. More...

struct GeomIndexTypeInfo

Used for Vector, Twist and Wrench. More...

class KDLToolkitPlugin

This interface defines the types of the kdl. More...

class CartPos2Jnt

calculates joint values from a cartesian position. More...

class CartVel2Jnt

calculates cartesian position form the joint values. More...

class CRS450

constructs a ZXXZXZ object with the parameters of a CRS 450 robot. More...

class CRS450Feath

class Jnt2CartPos

calculates cartesian position form the joint values. More...

class Jnt2CartVel

calculates cartesian position form the joint values. More...

class Jnt2Jac

calculates Jacobian and cartesian position from the joint values. More...

class Joint

encapsulates a simple joint. More...

class JointRotX

implements Joint for a rotation around X More...

class JointRotY

implements Joint for a rotation around Y More...

class JointRotZ

implements Joint for a rotation around Y More...

class JointTransX

implements Joint for a translation around X More...

class JointTransY

implements Joint for a translation around X More...

class JointTransZ

implements Joint for a translation around X More...

class KinematicFamily

Interface to define a kinematic family. More...

class Kuka160

constructs a ZXXZXZ object with the parameters of a Kuka160 robot. More...

class Kuka361

constructs a ZXXZXZ object with the parameters of a Kuka361 robot. More...

class Kuka361Transmission

This transmission transforms the kinematics of a kuka 361 robot with a Dubbel Winkel Hand (DWH) wrist kinematics to ZXXZXZ kinematics. More...

class LinearTransmission

implementation of Transmission in the case of a linear transformation. More...

class Robuter

constructs a SerialChain kinematic object corresponding to our robuter platform with a mounted robot. More...

class SerialChain

Implementation of KinematicFamily for serial chains. More...

class SerialChainCartPos2Jnt

calculates joint values from a cartesian position. More...

class SerialChainCartVel2Jnt

calculates joint values from a cartesian position. More...

class SerialChainJnt2CartPos

implements Jnt2CartPos for a serial chain. More...

class SerialChainJnt2CartVel

implements Jnt2Jac for a serial chain. More...

class SerialChainJnt2Jac

implements Jnt2Jac for a serial chain. More...

class Transformation

Base class for all transformations. More...

class Transmission

Transforms between actuator space and geometric space. More...

class Connection

class KinematicTree

Implementation of KinematicFamily for trees. More...

class KinematicTreeJnt2CartPos

class Node

Implementation of Node. More...

class UnitTransmission

implementation of Transmission in the case of no transformation. More...

class ZXXZXZ

implements KinematicFamily for a ZXXZXZ kinematic chain. More...

class ZXXZXZCartPos2Jnt

calculates joint values from a cartesian position. More...

class ZXXZXZCartVel2Jnt

class ZXXZXZJnt2CartPos

class ZXXZXZJnt2CartVel

class ZXXZXZJnt2Jac

implements Jnt2Jac for a serial chain. More...

class Path

The specification of the path of a trajectory. More...

class Path_Circle

A circular Path with 'open ends'. More...

class Path_Composite

A Path being the composition of other Path objects. More...

class Path_Cyclic_Closed

A Path representing a closed circular movement, which is traversed a number of times. More...

class Path_Line

A path representing a line from A to B. More...

class Path_Point

A Path consisting only of a point in space. More...

class Path_RoundedComposite

The specification of a path, composed of way-points with rounded corners. More...

class RotationalInterpolation

RotationalInterpolation specifies the rotational part of a geometric trajectory

The different derived objects specify different methods for interpolating rotations.
More...

class RotationalInterpolation_SingleAxis

An interpolation algorithm which rotates a frame over the existing single rotation axis formed by start and end rotation. More...

class Trajectory

An abstract class that implements a trajectory contains a cartesian space trajectory and an underlying velocity profile. More...

class Trajectory_Segment

Trajectory_Segment combines a VelocityProfile and a Path into a trajectory. More...

class VelocityProfile

A VelocityProfile stores the velocity profile that is used within a trajectory. More...

class VelocityProfile_Dirac

A Dirac VelocityProfile generates an infinite velocity so that the position jumps from A to B in in infinite short time. More...

class VelocityProfile_Rectangular

A rectangular VelocityProfile generates a constant velocity for moving from A to B. More...

class VelocityProfile_Trap

A Trapezoidal VelocityProfile implementation. More...

class VelocityProfile_TrapHalf

A 'Half' Trapezoidal VelocityProfile. More...

class Plane

This class represents a plane in cartesian space. More...

class Rall1d

Rall1d contains a value, and its gradient, and defines an algebraic structure on this pair. More...

class Rall2d

Rall2d contains a value, and its gradient and its 2nd derivative, and defines an algebraic structure on this pair. More...

class Stiffness

Preliminary class to implement Stiffness, only diagonal stiffness is implemented no transformations provided. More...

Typedefs

typedef std::stack< std::string > ErrorStack

typedef Rall2d< double, double,
double > doubleAcc

typedef Rall1d< double > doubleVel

typedef std::vector< Joint * > JointList

a list of Joints describing a serial chain.

Functions

std::ofstream & logger ()

std::ofstream & errorlogger ()

void IOTrace (const std::string &description)

void IOTracePop ()

pops a description of the IO-stack

void IOTraceOutput (std::ostream &os)

outputs the IO-stack to a stream to provide a better errormessage.

void IOTracePopStr (char *buffer, int size)

outputs one element of the IO-stack to the buffer (maximally size chars) returns empty string if no elements on the stack.

VectorAcc operator+ (const VectorAcc &r1, const VectorAcc &r2)

VectorAcc operator- (const VectorAcc &r1, const VectorAcc &r2)

VectorAcc operator+ (const Vector &r1, const VectorAcc &r2)

VectorAcc operator- (const Vector &r1, const VectorAcc &r2)

VectorAcc operator+ (const VectorAcc &r1, const Vector &r2)

VectorAcc operator- (const VectorAcc &r1, const Vector &r2)

VectorAcc operator- (const VectorAcc &r)

VectorAcc operator * (const VectorAcc &r1, const VectorAcc &r2)

VectorAcc operator * (const VectorAcc &r1, const Vector &r2)

VectorAcc operator * (const Vector &r1, const VectorAcc &r2)

VectorAcc operator * (double r1, const VectorAcc &r2)

VectorAcc operator * (const VectorAcc &r1, double r2)

VectorAcc operator * (const doubleAcc &r1, const VectorAcc &r2)

VectorAcc operator * (const VectorAcc &r2, const doubleAcc &r1)

doubleAcc dot (const VectorAcc &lhs, const VectorAcc &rhs)

doubleAcc dot (const VectorAcc &lhs, const Vector &rhs)

doubleAcc dot (const Vector &lhs, const VectorAcc &rhs)

bool Equal (const VectorAcc &r1, const VectorAcc &r2, double eps)

bool Equal (const Vector &r1, const VectorAcc &r2, double eps)

bool Equal (const VectorAcc &r1, const Vector &r2, double eps)

VectorAcc operator/ (const VectorAcc &r1, double r2)

VectorAcc operator/ (const VectorAcc &r2, const doubleAcc &r1)

RotationAcc operator * (const RotationAcc &r1, const RotationAcc &r2)

RotationAcc operator * (const Rotation &r1, const RotationAcc &r2)

RotationAcc operator * (const RotationAcc &r1, const Rotation &r2)

VectorAcc operator * (const Rotation &R, const VectorAcc &x)

bool Equal (const RotationAcc &r1, const RotationAcc &r2, double eps)

bool Equal (const Rotation &r1, const RotationAcc &r2, double eps)

bool Equal (const RotationAcc &r1, const Rotation &r2, double eps)

FrameAcc operator * (const FrameAcc &lhs, const FrameAcc &rhs)

FrameAcc operator * (const FrameAcc &lhs, const Frame &rhs)

FrameAcc operator * (const Frame &lhs, const FrameAcc &rhs)

bool Equal (const FrameAcc &r1, const FrameAcc &r2, double eps)

bool Equal (const Frame &r1, const FrameAcc &r2, double eps)

bool Equal (const FrameAcc &r1, const Frame &r2, double eps)

TwistAcc operator * (const TwistAcc &lhs, double rhs)

TwistAcc operator * (double lhs, const TwistAcc &rhs)

TwistAcc operator/ (const TwistAcc &lhs, double rhs)

TwistAcc operator * (const TwistAcc &lhs, const doubleAcc &rhs)

TwistAcc operator * (const doubleAcc &lhs, const TwistAcc &rhs)

TwistAcc operator/ (const TwistAcc &lhs, const doubleAcc &rhs)

TwistAcc operator+ (const TwistAcc &lhs, const TwistAcc &rhs)

TwistAcc operator- (const TwistAcc &lhs, const TwistAcc &rhs)

TwistAcc operator- (const TwistAcc &arg)

bool Equal (const TwistAcc &a, const TwistAcc &b, double eps)

bool Equal (const Twist &a, const TwistAcc &b, double eps)

bool Equal (const TwistAcc &a, const Twist &b, double eps)

std::ostream & operator<< (std::ostream &os, const VectorAcc &r)

std::ostream & operator<< (std::ostream &os, const RotationAcc &r)

std::ostream & operator<< (std::ostream &os, const FrameAcc &r)

std::ostream & operator<< (std::ostream &os, const TwistAcc &r)

bool Equal (const Rotation &a, const Rotation &b, double eps)

Rotation operator * (const Rotation &lhs, const Rotation &rhs)

bool operator== (const Rotation &a, const Rotation &b)

IMETHOD Vector diff (const Vector &a, const Vector &b, double dt=1)

IMETHOD Vector diff (const Rotation &R_a_b1, const Rotation &R_a_b2, double dt=1)

IMETHOD Twist diff (const Frame &F_a_b1, const Frame &F_a_b2, double dt=1)

IMETHOD Twist diff (const Twist &a, const Twist &b, double dt=1)

IMETHOD Wrench diff (const Wrench &W_a_p1, const Wrench &W_a_p2, double dt=1)

IMETHOD Vector addDelta (const Vector &a, const Vector &da, double dt=1)

IMETHOD Rotation addDelta (const Rotation &a, const Vector &da, double dt=1)

IMETHOD Frame addDelta (const Frame &a, const Twist &da, double dt=1)

IMETHOD Twist addDelta (const Twist &a, const Twist &da, double dt=1)

IMETHOD Wrench addDelta (const Wrench &a, const Wrench &da, double dt=1)

std::ostream & operator<< (std::ostream &os, const Vector &v)

width to be used when printing variables out with frames_io.h global variable, can be changed.

std::ostream & operator<< (std::ostream &os, const Twist &v)

std::ostream & operator<< (std::ostream &os, const Wrench &v)

std::ostream & operator<< (std::ostream &os, const Rotation &R)

std::ostream & operator<< (std::ostream &os, const Frame &T)

std::ostream & operator<< (std::ostream &os, const Vector2 &v)

std::ostream & operator<< (std::ostream &os, const Rotation2 &R)

std::ostream & operator<< (std::ostream &os, const Frame2 &T)

std::istream & operator>> (std::istream &is, Vector &v)

std::istream & operator>> (std::istream &is, Twist &v)

std::istream & operator>> (std::istream &is, Wrench &v)

std::istream & operator>> (std::istream &is, Rotation &r)

std::istream & operator>> (std::istream &is, Frame &T)

std::istream & operator>> (std::istream &is, Vector2 &v)

std::istream & operator>> (std::istream &is, Rotation2 &r)

std::istream & operator>> (std::istream &is, Frame2 &T)

IMETHOD doubleVel diff (const doubleVel &a, const doubleVel &b, double dt=1.0)

IMETHOD doubleVel addDelta (const doubleVel &a, const doubleVel &da, double dt=1.0)

IMETHOD void random (doubleVel &F)

IMETHOD void posrandom (doubleVel &F)

IMETHOD VectorVel diff (const VectorVel &a, const VectorVel &b, double dt=1.0)

IMETHOD VectorVel addDelta (const VectorVel &a, const VectorVel &da, double dt=1.0)

IMETHOD VectorVel diff (const RotationVel &a, const RotationVel &b, double dt=1.0)

IMETHOD RotationVel addDelta (const RotationVel &a, const VectorVel &da, double dt=1.0)

IMETHOD TwistVel diff (const FrameVel &a, const FrameVel &b, double dt=1.0)

IMETHOD FrameVel addDelta (const FrameVel &a, const TwistVel &da, double dt=1.0)

IMETHOD void random (VectorVel &a)

IMETHOD void random (TwistVel &a)

IMETHOD void random (RotationVel &R)

IMETHOD void random (FrameVel &F)

IMETHOD void posrandom (VectorVel &a)

IMETHOD void posrandom (TwistVel &a)

IMETHOD void posrandom (RotationVel &R)

IMETHOD void posrandom (FrameVel &F)

std::ostream & operator<< (std::ostream &os, const VectorVel &r)

std::ostream & operator<< (std::ostream &os, const RotationVel &r)

std::ostream & operator<< (std::ostream &os, const FrameVel &r)

std::ostream & operator<< (std::ostream &os, const TwistVel &r)

template<class T, int N>

INLINE FVector< T, N > operator+ (const FVector< T, N > &a, const FVector< T, N > &b)

template<class T, int N>

INLINE FVector< T, N > operator- (const FVector< T, N > &a, const FVector< T, N > &b)

template<class T, int N>

INLINE FVector< T, N > operator- (const FVector< T, N > &a)

template<class T, int N>

INLINE FVector< T, N > operator * (typename TI< T >::Arg a, const FVector< T, N > &b)

template<class T, int N>

INLINE FVector< T, N > operator * (const FVector< T, N > &a, typename TI< T >::Arg b)

template<class T, int N>

INLINE FVector< T, N > operator/ (const FVector< T, N > &a, typename TI< T >::Arg b)

template<class T, int N>

INLINE double Norm (const FVector< T, N > &a)

template<class T, int N>

INLINE FVector< T, N > LinComb (typename TI< T >::Arg alfa, const FVector< T, N > &a, typename TI< T >::Arg beta, const FVector< T, N > &b)

template<class T, int N>

INLINE void LinCombR (typename TI< T >::Arg alfa, const FVector< T, N > &a, typename TI< T >::Arg beta, const FVector< T, N > &b, FVector< T, N > &result)

template<class T, int N>

INLINE void SetToZero (FVector< T, N > &value)

template<class T, int N>

INLINE void SetToIdentity (FVector< T, N > &value)

template<class T, int N>

bool Equal (const FVector< T, N > &a, const FVector< T, N > &b, double eps)

template<class T, int N, class S>

INLINE FVector2< T, N, S > operator+ (const FVector2< T, N, S > &a, const FVector2< T, N, S > &b)

template<class T, int N, class S>

INLINE FVector2< T, N, S > operator- (const FVector2< T, N, S > &a, const FVector2< T, N, S > &b)

template<class T, int N, class S>

INLINE FVector2< T, N, S > operator- (const FVector2< T, N, S > &a)

template<class T, int N, class S>

INLINE FVector2< T, N, S > operator * (const T &a, const FVector2< T, N, S > &b)

template<class T, int N, class S>

INLINE FVector2< T, N, S > operator * (const FVector2< T, N, S > &a, const T &b)

template<class T, int N, class S>

INLINE FVector2< T, N, S > operator * (S a, const FVector2< T, N, S > &b)

template<class T, int N, class S>

INLINE FVector2< T, N, S > operator * (const FVector2< T, N, S > &a, S b)

template<class T, int N, class S>

INLINE FVector2< T, N, S > operator/ (const FVector2< T, N, S > &a, const T &b)

template<class T, int N, class S>

INLINE double Norm (const FVector2< T, N, S > &a)

template<class T, int N, class S>

INLINE FVector2< T, N, S > LinComb (const T &alfa, const FVector2< T, N, S > &a, const T &beta, const FVector2< T, N, S > &b)

template<class T, int N, class S>

INLINE void LinCombR (const T &alfa, const FVector2< T, N, S > &a, const T &beta, const FVector2< T, N, S > &b, FVector2< T, N, S > &result)

template<class T, int N, class S>

INLINE void SetToZero (FVector2< T, N, S > &value)

template<class T, int N, class S>

bool Equal (const FVector2< T, N, S > &a, const FVector2< T, N, S > &b, double eps)

template<class T, int N, class S>

bool Equal (const T &a, const FVector2< T, N, S > &b, double eps)

template<class T, int N, class S>

bool Equal (const FVector2< T, N, S > &a, const T &b, double eps)

template<class T, int N, class S>

std::ostream & operator<< (std::ostream &os, const FVector2< T, N, S > &v)

template<class T, int N>

std::ostream & operator<< (std::ostream &os, const FVector< T, N > &v)

int GetEulerZYX (const Jacobian< Rotation > &JR, Jacobian< double > &gamma, Jacobian< double > &beta, Jacobian< double > &alpha, double eps)

function to get the euler zyx angles.

void SetEulerZYX (const Jacobian< double > &gamma, const Jacobian< double > &beta, const Jacobian< double > &alpha, Jacobian< Rotation > &JR)

funcion to set the euler zyx angles.

DEFUNARY_TYPE (Inverse, OpInverse, Ref< Jacobian< FrameVel > >)

DEFUNARY_TYPE (Inverse, OpInverse, Ref< Jacobian< RotationVel > >)

DEFUNARY_TYPE (RotMat, OpRotation, Ref< Jacobian< FrameVel > >)

DEFUNARY_TYPE (Origin, OpOrigin, Ref< Jacobian< FrameVel > >)

DEFUNARY_TYPE (UnitX, OpUnitX, Ref< Jacobian< RotationVel > >)

DEFUNARY_TYPE (UnitY, OpUnitY, Ref< Jacobian< RotationVel > >)

DEFUNARY_TYPE (UnitZ, OpUnitZ, Ref< Jacobian< RotationVel > >)

DEFUNARY_TYPE (CoordX, OpCoordX, Ref< Jacobian< VectorVel > >)

DEFUNARY_TYPE (CoordY, OpCoordY, Ref< Jacobian< VectorVel > >)

DEFUNARY_TYPE (CoordZ, OpCoordZ, Ref< Jacobian< VectorVel > >)

Double6D double6Dd (double d)

Double6D double6D6d (double a, double b, double c, double d, double e, double f)

Frame framevr (const Vector &v, const Rotation &r)

Frame framerv (const Rotation &r, const Vector &v)

Wrench wrenchft (const Vector &force, const Vector &torque)

Twist twistvw (const Vector &trans, const Vector &rot)

Vector vectorxyz (double a, double b, double c)

double double6D_index (Double6D d6, int index)

std::ostream & operator<< (std::ostream &os, const Joint *r)

Writes a Joint to a stream.

Joint * readJoint (std::istream &is)

reads from a stream and creates a Joint.

void readKinematicFamilies (std::istream &is, std::vector< KinematicFamily * > &chains)

reads the input stream and creates a KinematicFamily object

KinematicFamily * readKinematicFamily (std::istream &is)

reads the input stream and creates a KinematicFamily object

std::ostream & operator<< (std::ostream &os, const std::vector< KinematicFamily * > &chains)

writes the KinematicFamily object to an output stream.

std::ostream & operator<< (std::ostream &os, const KinematicFamily *chain)

writes the KinematicFamily object to an output stream.

ostream & operator<< (std::ostream &os, const SerialChain *chain)

writes the SerialChain object to an output stream.

SerialChain * readSerialChain (std::istream &is, bool keyword=true)

reads the input stream and creates a SerialChain object

Transmission * readTransmission (std::istream &is)

reads the input stream and creates a Transmission object

std::ostream & operator<< (std::ostream &os, const Transmission *trans)

writes a Transmission oject to an output stream.

ZXXZXZ * readZXXZXZ (std::istream &is, bool keyword=true)

reads the input stream and creates a zxxzxz object

std::ostream & operator<< (std::ostream &os, const ZXXZXZ *chain)

writes the zxxzxz object to an output stream.

template<class T, class V, class S>

INLINE Rall1d< T, V, S > operator/ (const Rall1d< T, V, S > &lhs, const Rall1d< T, V, S > &rhs)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > operator * (const Rall1d< T, V, S > &lhs, const Rall1d< T, V, S > &rhs)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > operator+ (const Rall1d< T, V, S > &lhs, const Rall1d< T, V, S > &rhs)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > operator- (const Rall1d< T, V, S > &lhs, const Rall1d< T, V, S > &rhs)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > operator- (const Rall1d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > operator * (S s, const Rall1d< T, V, S > &v)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > operator * (const Rall1d< T, V, S > &v, S s)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > operator+ (S s, const Rall1d< T, V, S > &v)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > operator+ (const Rall1d< T, V, S > &v, S s)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > operator- (S s, const Rall1d< T, V, S > &v)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > operator- (const Rall1d< T, V, S > &v, S s)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > operator/ (S s, const Rall1d< T, V, S > &v)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > operator/ (const Rall1d< T, V, S > &v, S s)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > exp (const Rall1d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > log (const Rall1d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > sin (const Rall1d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > cos (const Rall1d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > tan (const Rall1d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > sinh (const Rall1d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > cosh (const Rall1d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > sqr (const Rall1d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > pow (const Rall1d< T, V, S > &arg, double m)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > sqrt (const Rall1d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > atan (const Rall1d< T, V, S > &x)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > hypot (const Rall1d< T, V, S > &y, const Rall1d< T, V, S > &x)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > asin (const Rall1d< T, V, S > &x)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > acos (const Rall1d< T, V, S > &x)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > abs (const Rall1d< T, V, S > &x)

template<class T, class V, class S>

INLINE S Norm (const Rall1d< T, V, S > &value)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > tanh (const Rall1d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > atan2 (const Rall1d< T, V, S > &y, const Rall1d< T, V, S > &x)

template<class T, class V, class S>

INLINE Rall1d< T, V, S > LinComb (S alfa, const Rall1d< T, V, S > &a, const T &beta, const Rall1d< T, V, S > &b)

template<class T, class V, class S>

INLINE void LinCombR (S alfa, const Rall1d< T, V, S > &a, const T &beta, const Rall1d< T, V, S > &b, Rall1d< T, V, S > &result)

template<class T, class V, class S>

INLINE void SetToZero (Rall1d< T, V, S > &value)

template<class T, class V, class S>

INLINE void SetToIdentity (Rall1d< T, V, S > &value)

template<class T, class V, class S>

INLINE bool Equal (const Rall1d< T, V, S > &y, const Rall1d< T, V, S > &x, double eps=epsilon)

template<class T, class V, class S>

std::ostream & operator<< (std::ostream &os, const Rall1d< T, V, S > &r)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > operator/ (const Rall2d< T, V, S > &lhs, const Rall2d< T, V, S > &rhs)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > operator * (const Rall2d< T, V, S > &lhs, const Rall2d< T, V, S > &rhs)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > operator+ (const Rall2d< T, V, S > &lhs, const Rall2d< T, V, S > &rhs)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > operator- (const Rall2d< T, V, S > &lhs, const Rall2d< T, V, S > &rhs)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > operator- (const Rall2d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > operator * (S s, const Rall2d< T, V, S > &v)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > operator * (const Rall2d< T, V, S > &v, S s)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > operator+ (S s, const Rall2d< T, V, S > &v)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > operator+ (const Rall2d< T, V, S > &v, S s)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > operator- (S s, const Rall2d< T, V, S > &v)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > operator- (const Rall2d< T, V, S > &v, S s)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > operator/ (S s, const Rall2d< T, V, S > &rhs)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > operator/ (const Rall2d< T, V, S > &v, S s)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > exp (const Rall2d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > log (const Rall2d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > sin (const Rall2d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > cos (const Rall2d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > tan (const Rall2d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > sinh (const Rall2d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > cosh (const Rall2d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > tanh (const Rall2d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > sqr (const Rall2d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > pow (const Rall2d< T, V, S > &arg, double m)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > sqrt (const Rall2d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > asin (const Rall2d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > acos (const Rall2d< T, V, S > &arg)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > atan (const Rall2d< T, V, S > &x)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > atan2 (const Rall2d< T, V, S > &y, const Rall2d< T, V, S > &x)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > abs (const Rall2d< T, V, S > &x)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > hypot (const Rall2d< T, V, S > &y, const Rall2d< T, V, S > &x)

template<class T, class V, class S>

INLINE S Norm (const Rall2d< T, V, S > &value)

template<class T, class V, class S>

INLINE Rall2d< T, V, S > LinComb (S alfa, const Rall2d< T, V, S > &a, const T &beta, const Rall2d< T, V, S > &b)

template<class T, class V, class S>

INLINE void LinCombR (S alfa, const Rall2d< T, V, S > &a, const T &beta, const Rall2d< T, V, S > &b, Rall2d< T, V, S > &result)

template<class T, class V, class S>

INLINE void SetToZero (Rall2d< T, V, S > &value)

template<class T, class V, class S>

INLINE void SetToIdentity (Rall2d< T, V, S > &value)

template<class T, class V, class S>

INLINE bool Equal (const Rall2d< T, V, S > &y, const Rall2d< T, V, S > &x, double eps=epsilon)

template<class T, class V, class S>

std::ostream & operator<< (std::ostream &os, const Rall2d< T, V, S > &r)

Wrench operator * (const Stiffness &s, const Twist &t)

Stiffness operator+ (const Stiffness &s1, const Stiffness &s2)

void posrandom (Stiffness &F)

void random (Stiffness &F)

Variables

int DEBUG_RETURNVALUE

ErrorStack errorstack

KDLToolkitPlugin KDLToolkit

The single global instance of the KDL Toolkit.

KDLToolkitPlugin KDLToolkit

The single global instance of the KDL Toolkit.

static const double SQRT3d2 = 0.8660254037844386

implementation of Transmission in the case of a Kuka 361 robot.

static const double M_PI_T2 = 2 * M_PI

static const double SQRT3t2 = 3.46410161513775

Typedef Documentation

typedef std::stack<std::string> KDL::ErrorStack

typedef Rall2d<double,double,double> KDL::doubleAcc

typedef Rall1d<double> KDL::doubleVel

typedef std::vector<Joint*> KDL::JointList

a list of Joints describing a serial chain.

Function Documentation

std::ofstream& KDL::logger ( )

std::ofstream& KDL::errorlogger ( )

void KDL::IOTrace ( const std::string & description )

void KDL::IOTracePop ( )

pops a description of the IO-stack

void KDL::IOTraceOutput ( std::ostream & os )

outputs the IO-stack to a stream to provide a better errormessage.

void KDL::IOTracePopStr	(	char *	buffer,
		int	size
	)

outputs one element of the IO-stack to the buffer (maximally size chars) returns empty string if no elements on the stack.

VectorAcc KDL::operator+	(	const VectorAcc &	r1,
		const VectorAcc &	r2
	)

VectorAcc KDL::operator-	(	const VectorAcc &	r1,
		const VectorAcc &	r2
	)

VectorAcc KDL::operator+	(	const Vector &	r1,
		const VectorAcc &	r2
	)

VectorAcc KDL::operator-	(	const Vector &	r1,
		const VectorAcc &	r2
	)

VectorAcc KDL::operator+	(	const VectorAcc &	r1,
		const Vector &	r2
	)

VectorAcc KDL::operator-	(	const VectorAcc &	r1,
		const Vector &	r2
	)

VectorAcc KDL::operator- ( const VectorAcc & r )

VectorAcc KDL::operator *	(	const VectorAcc &	r1,
		const VectorAcc &	r2
	)

VectorAcc KDL::operator *	(	const VectorAcc &	r1,
		const Vector &	r2
	)

VectorAcc KDL::operator *	(	const Vector &	r1,
		const VectorAcc &	r2
	)

VectorAcc KDL::operator *	(	double	r1,
		const VectorAcc &	r2
	)

VectorAcc KDL::operator *	(	const VectorAcc &	r1,
		double	r2
	)

VectorAcc KDL::operator *	(	const doubleAcc &	r1,
		const VectorAcc &	r2
	)

VectorAcc KDL::operator *	(	const VectorAcc &	r2,
		const doubleAcc &	r1
	)

doubleAcc KDL::dot	(	const VectorAcc &	lhs,
		const VectorAcc &	rhs
	)

doubleAcc KDL::dot	(	const VectorAcc &	lhs,
		const Vector &	rhs
	)

doubleAcc KDL::dot	(	const Vector &	lhs,
		const VectorAcc &	rhs
	)

bool KDL::Equal	(	const VectorAcc &	r1,
		const VectorAcc &	r2,
		double	eps = `epsilon`
	)

bool KDL::Equal	(	const Vector &	r1,
		const VectorAcc &	r2,
		double	eps = `epsilon`
	)

bool KDL::Equal	(	const VectorAcc &	r1,
		const Vector &	r2,
		double	eps = `epsilon`
	)

VectorAcc KDL::operator/	(	const VectorAcc &	r1,
		double	r2
	)

VectorAcc KDL::operator/	(	const VectorAcc &	r2,
		const doubleAcc &	r1
	)

RotationAcc KDL::operator *	(	const RotationAcc &	r1,
		const RotationAcc &	r2
	)

RotationAcc KDL::operator *	(	const Rotation &	r1,
		const RotationAcc &	r2
	)

RotationAcc KDL::operator *	(	const RotationAcc &	r1,
		const Rotation &	r2
	)

VectorAcc KDL::operator *	(	const Rotation &	R,
		const VectorAcc &	x
	)

bool KDL::Equal	(	const RotationAcc &	r1,
		const RotationAcc &	r2,
		double	eps = `epsilon`
	)

bool KDL::Equal	(	const Rotation &	r1,
		const RotationAcc &	r2,
		double	eps = `epsilon`
	)

bool KDL::Equal	(	const RotationAcc &	r1,
		const Rotation &	r2,
		double	eps = `epsilon`
	)

FrameAcc KDL::operator *	(	const FrameAcc &	lhs,
		const FrameAcc &	rhs
	)

FrameAcc KDL::operator *	(	const FrameAcc &	lhs,
		const Frame &	rhs
	)

FrameAcc KDL::operator *	(	const Frame &	lhs,
		const FrameAcc &	rhs
	)

bool KDL::Equal	(	const FrameAcc &	r1,
		const FrameAcc &	r2,
		double	eps = `epsilon`
	)

bool KDL::Equal	(	const Frame &	r1,
		const FrameAcc &	r2,
		double	eps = `epsilon`
	)

bool KDL::Equal	(	const FrameAcc &	r1,
		const Frame &	r2,
		double	eps = `epsilon`
	)

TwistAcc KDL::operator *	(	const TwistAcc &	lhs,
		double	rhs
	)

TwistAcc KDL::operator *	(	double	lhs,
		const TwistAcc &	rhs
	)

TwistAcc KDL::operator/	(	const TwistAcc &	lhs,
		double	rhs
	)

TwistAcc KDL::operator *	(	const TwistAcc &	lhs,
		const doubleAcc &	rhs
	)

TwistAcc KDL::operator *	(	const doubleAcc &	lhs,
		const TwistAcc &	rhs
	)

TwistAcc KDL::operator/	(	const TwistAcc &	lhs,
		const doubleAcc &	rhs
	)

TwistAcc KDL::operator+	(	const TwistAcc &	lhs,
		const TwistAcc &	rhs
	)

TwistAcc KDL::operator-	(	const TwistAcc &	lhs,
		const TwistAcc &	rhs
	)

TwistAcc KDL::operator- ( const TwistAcc & arg )

bool KDL::Equal	(	const TwistAcc &	a,
		const TwistAcc &	b,
		double	eps = `epsilon`
	)

bool KDL::Equal	(	const Twist &	a,
		const TwistAcc &	b,
		double	eps = `epsilon`
	)

bool KDL::Equal	(	const TwistAcc &	a,
		const Twist &	b,
		double	eps = `epsilon`
	)

std::ostream& KDL::operator<<	(	std::ostream &	os,
		const VectorAcc &	r
	)			`[inline]`

std::ostream& KDL::operator<<	(	std::ostream &	os,
		const RotationAcc &	r
	)			`[inline]`

std::ostream& KDL::operator<<	(	std::ostream &	os,
		const FrameAcc &	r
	)			`[inline]`

std::ostream& KDL::operator<<	(	std::ostream &	os,
		const TwistAcc &	r
	)			`[inline]`

bool KDL::Equal	(	const Rotation &	a,
		const Rotation &	b,
		double	eps = `epsilon`
	)

) is slightly different. It compares whether the 2 arguments are equal in an eps-interval

Rotation KDL::operator *	(	const Rotation &	lhs,
		const Rotation &	rhs
	)

bool KDL::operator==	(	const Rotation &	a,
		const Rotation &	b
	)

IMETHOD Vector KDL::diff	(	const Vector &	a,
		const Vector &	b,
		double	dt = `1`
	)

IMETHOD Vector KDL::diff	(	const Rotation &	R_a_b1,
		const Rotation &	R_a_b2,
		double	dt = `1`
	)

IMETHOD Twist KDL::diff	(	const Frame &	F_a_b1,
		const Frame &	F_a_b2,
		double	dt = `1`
	)

IMETHOD Twist KDL::diff	(	const Twist &	a,
		const Twist &	b,
		double	dt = `1`
	)

IMETHOD Wrench KDL::diff	(	const Wrench &	W_a_p1,
		const Wrench &	W_a_p2,
		double	dt = `1`
	)

IMETHOD Vector KDL::addDelta	(	const Vector &	a,
		const Vector &	da,
		double	dt = `1`
	)

IMETHOD Rotation KDL::addDelta	(	const Rotation &	a,
		const Vector &	da,
		double	dt = `1`
	)

IMETHOD Frame KDL::addDelta	(	const Frame &	a,
		const Twist &	da,
		double	dt = `1`
	)

IMETHOD Twist KDL::addDelta	(	const Twist &	a,
		const Twist &	da,
		double	dt = `1`
	)

IMETHOD Wrench KDL::addDelta	(	const Wrench &	a,
		const Wrench &	da,
		double	dt = `1`
	)

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Vector &	v
	)

width to be used when printing variables out with frames_io.h global variable, can be changed.

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Twist &	v
	)

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Wrench &	v
	)

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Rotation &	R
	)

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Frame &	T
	)

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Vector2 &	v
	)

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Rotation2 &	R
	)

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Frame2 &	T
	)

std::istream & KDL::operator>>	(	std::istream &	is,
		Vector &	v
	)

std::istream & KDL::operator>>	(	std::istream &	is,
		Twist &	v
	)

std::istream & KDL::operator>>	(	std::istream &	is,
		Wrench &	v
	)

std::istream & KDL::operator>>	(	std::istream &	is,
		Rotation &	r
	)

std::istream & KDL::operator>>	(	std::istream &	is,
		Frame &	T
	)

std::istream & KDL::operator>>	(	std::istream &	is,
		Vector2 &	v
	)

std::istream & KDL::operator>>	(	std::istream &	is,
		Rotation2 &	r
	)

std::istream & KDL::operator>>	(	std::istream &	is,
		Frame2 &	T
	)

IMETHOD doubleVel KDL::diff	(	const doubleVel &	a,
		const doubleVel &	b,
		double	dt = `1.0`
	)

IMETHOD doubleVel KDL::addDelta	(	const doubleVel &	a,
		const doubleVel &	da,
		double	dt = `1.0`
	)

IMETHOD void KDL::random ( doubleVel & F )

IMETHOD void KDL::posrandom ( doubleVel & F )

IMETHOD VectorVel KDL::diff	(	const VectorVel &	a,
		const VectorVel &	b,
		double	dt = `1.0`
	)

IMETHOD VectorVel KDL::addDelta	(	const VectorVel &	a,
		const VectorVel &	da,
		double	dt = `1.0`
	)

IMETHOD VectorVel KDL::diff	(	const RotationVel &	a,
		const RotationVel &	b,
		double	dt = `1.0`
	)

IMETHOD RotationVel KDL::addDelta	(	const RotationVel &	a,
		const VectorVel &	da,
		double	dt = `1.0`
	)

IMETHOD TwistVel KDL::diff	(	const FrameVel &	a,
		const FrameVel &	b,
		double	dt = `1.0`
	)

IMETHOD FrameVel KDL::addDelta	(	const FrameVel &	a,
		const TwistVel &	da,
		double	dt = `1.0`
	)

IMETHOD void KDL::random ( VectorVel & a )

IMETHOD void KDL::random ( TwistVel & a )

IMETHOD void KDL::random ( RotationVel & R )

IMETHOD void KDL::random ( FrameVel & F )

IMETHOD void KDL::posrandom ( VectorVel & a )

IMETHOD void KDL::posrandom ( TwistVel & a )

IMETHOD void KDL::posrandom ( RotationVel & R )

IMETHOD void KDL::posrandom ( FrameVel & F )

std::ostream& KDL::operator<<	(	std::ostream &	os,
		const VectorVel &	r
	)			`[inline]`

std::ostream& KDL::operator<<	(	std::ostream &	os,
		const RotationVel &	r
	)			`[inline]`

std::ostream& KDL::operator<<	(	std::ostream &	os,
		const FrameVel &	r
	)			`[inline]`

std::ostream& KDL::operator<<	(	std::ostream &	os,
		const TwistVel &	r
	)			`[inline]`

template<class T, int N>

INLINE FVector<T,N> KDL::operator+	(	const FVector< T, N > &	a,
		const FVector< T, N > &	b
	)

template<class T, int N>

INLINE FVector<T,N> KDL::operator-	(	const FVector< T, N > &	a,
		const FVector< T, N > &	b
	)

template<class T, int N>

INLINE FVector<T,N> KDL::operator- ( const FVector< T, N > & a )

template<class T, int N>

INLINE FVector<T,N> KDL::operator *	(	typename TI< T >::Arg	a,
		const FVector< T, N > &	b
	)

template<class T, int N>

INLINE FVector<T,N> KDL::operator *	(	const FVector< T, N > &	a,
		typename TI< T >::Arg	b
	)

template<class T, int N>

INLINE FVector<T,N> KDL::operator/	(	const FVector< T, N > &	a,
		typename TI< T >::Arg	b
	)

template<class T, int N>

INLINE double KDL::Norm ( const FVector< T, N > & a )

template<class T, int N>

INLINE FVector<T,N> KDL::LinComb	(	typename TI< T >::Arg	alfa,
		const FVector< T, N > &	a,
		typename TI< T >::Arg	beta,
		const FVector< T, N > &	b
	)

template<class T, int N>

INLINE void KDL::LinCombR	(	typename TI< T >::Arg	alfa,
		const FVector< T, N > &	a,
		typename TI< T >::Arg	beta,
		const FVector< T, N > &	b,
		FVector< T, N > &	result
	)

template<class T, int N>

INLINE void KDL::SetToZero ( FVector< T, N > & value )

template<class T, int N>

INLINE void KDL::SetToIdentity ( FVector< T, N > & value )

template<class T, int N>

bool KDL::Equal	(	const FVector< T, N > &	a,
		const FVector< T, N > &	b,
		double	eps
	)

template<class T, int N, class S>

INLINE FVector2<T,N,S> KDL::operator+	(	const FVector2< T, N, S > &	a,
		const FVector2< T, N, S > &	b
	)

template<class T, int N, class S>

INLINE FVector2<T,N,S> KDL::operator-	(	const FVector2< T, N, S > &	a,
		const FVector2< T, N, S > &	b
	)

template<class T, int N, class S>

INLINE FVector2<T,N,S> KDL::operator- ( const FVector2< T, N, S > & a )

template<class T, int N, class S>

INLINE FVector2<T,N,S> KDL::operator *	(	const T &	a,
		const FVector2< T, N, S > &	b
	)

template<class T, int N, class S>

INLINE FVector2<T,N,S> KDL::operator *	(	const FVector2< T, N, S > &	a,
		const T &	b
	)

template<class T, int N, class S>

INLINE FVector2<T,N,S> KDL::operator *	(	S	a,
		const FVector2< T, N, S > &	b
	)

template<class T, int N, class S>

INLINE FVector2<T,N,S> KDL::operator *	(	const FVector2< T, N, S > &	a,
		S	b
	)

template<class T, int N, class S>

INLINE FVector2<T,N,S> KDL::operator/	(	const FVector2< T, N, S > &	a,
		const T &	b
	)

template<class T, int N, class S>

INLINE double KDL::Norm ( const FVector2< T, N, S > & a )

template<class T, int N, class S>

INLINE FVector2<T,N,S> KDL::LinComb	(	const T &	alfa,
		const FVector2< T, N, S > &	a,
		const T &	beta,
		const FVector2< T, N, S > &	b
	)

template<class T, int N, class S>

INLINE void KDL::LinCombR	(	const T &	alfa,
		const FVector2< T, N, S > &	a,
		const T &	beta,
		const FVector2< T, N, S > &	b,
		FVector2< T, N, S > &	result
	)

template<class T, int N, class S>

INLINE void KDL::SetToZero ( FVector2< T, N, S > & value )

template<class T, int N, class S>

bool KDL::Equal	(	const FVector2< T, N, S > &	a,
		const FVector2< T, N, S > &	b,
		double	eps
	)

template<class T, int N, class S>

bool KDL::Equal	(	const T &	a,
		const FVector2< T, N, S > &	b,
		double	eps
	)

template<class T, int N, class S>

bool KDL::Equal	(	const FVector2< T, N, S > &	a,
		const T &	b,
		double	eps
	)

template<class T, int N, class S>

std::ostream& KDL::operator<<	(	std::ostream &	os,
		const FVector2< T, N, S > &	v
	)			`[inline]`

template<class T, int N>

std::ostream& KDL::operator<<	(	std::ostream &	os,
		const FVector< T, N > &	v
	)			`[inline]`

int KDL::GetEulerZYX	(	const Jacobian< Rotation > &	JR,
		Jacobian< double > &	gamma,
		Jacobian< double > &	beta,
		Jacobian< double > &	alpha,
		double	eps
	)

function to get the euler zyx angles.

Parameters:

	JR	input parameter that indicates the Rotation and Jacobian with the rotational velocities.
	gamma	output parameter will contain the amount of rotation around X.
	beta	output parameter will contain the amount of rotation around Y.
	alpha	output parameter will contain the amount of rotation around Z.

Return values:

if successfull, otherwise its a singular situation.

void KDL::SetEulerZYX	(	const Jacobian< double > &	gamma,
		const Jacobian< double > &	beta,
		const Jacobian< double > &	alpha,
		Jacobian< Rotation > &	JR
	)

funcion to set the euler zyx angles.

Parameters:

	gamma	input parameter that contains the amount of rotation around X.
	beta	input parameter that contains the amount of rotation around Y.
	alpha	output parameter that contains the amount of rotation around Z.
	JR	output parameter that will contain the Rotation and Jacobian with the rotational velocities.

KDL::DEFUNARY_TYPE	(	Inverse	,
		OpInverse	,
		Ref< Jacobian< FrameVel > >
	)

KDL::DEFUNARY_TYPE	(	Inverse	,
		OpInverse	,
		Ref< Jacobian< RotationVel > >
	)

KDL::DEFUNARY_TYPE	(	RotMat	,
		OpRotation	,
		Ref< Jacobian< FrameVel > >
	)

KDL::DEFUNARY_TYPE	(	Origin	,
		OpOrigin	,
		Ref< Jacobian< FrameVel > >
	)

KDL::DEFUNARY_TYPE	(	UnitX	,
		OpUnitX	,
		Ref< Jacobian< RotationVel > >
	)

KDL::DEFUNARY_TYPE	(	UnitY	,
		OpUnitY	,
		Ref< Jacobian< RotationVel > >
	)

KDL::DEFUNARY_TYPE	(	UnitZ	,
		OpUnitZ	,
		Ref< Jacobian< RotationVel > >
	)

KDL::DEFUNARY_TYPE	(	CoordX	,
		OpCoordX	,
		Ref< Jacobian< VectorVel > >
	)

KDL::DEFUNARY_TYPE	(	CoordY	,
		OpCoordY	,
		Ref< Jacobian< VectorVel > >
	)

KDL::DEFUNARY_TYPE	(	CoordZ	,
		OpCoordZ	,
		Ref< Jacobian< VectorVel > >
	)

Double6D KDL::@0::double6Dd ( double d ) [static]

Double6D KDL::@0::double6D6d	(	double	a,
		double	b,
		double	c,
		double	d,
		double	e,
		double	f
	)			`[static]`

Frame KDL::@0::framevr	(	const Vector &	v,
		const Rotation &	r
	)			`[static]`

Frame KDL::@0::framerv	(	const Rotation &	r,
		const Vector &	v
	)			`[static]`

Wrench KDL::@0::wrenchft	(	const Vector &	force,
		const Vector &	torque
	)			`[static]`

Twist KDL::@0::twistvw	(	const Vector &	trans,
		const Vector &	rot
	)			`[static]`

Vector KDL::@0::vectorxyz	(	double	a,
		double	b,
		double	c
	)			`[static]`

double KDL::@0::double6D_index	(	Double6D	d6,
		int	index
	)			`[static]`

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Joint *	r
	)

Writes a Joint to a stream.

Parameters:

	os	output stream.
	r	pointer to a joint.

Returns:: output stream.

Joint * KDL::readJoint ( std::istream & is )

reads from a stream and creates a Joint.

Parameters:

input stream

Returns:: pointer to the newly created Joint. The user is responsible for deleting this created Joint.

void KDL::readKinematicFamilies	(	std::istream &	is,
		std::vector< KinematicFamily * > &	chains
	)

reads the input stream and creates a KinematicFamily object

Parameters:

input stream

Returns:: a pointer to the created KinematicFamily object. The user is responsible for deleting this object.

KinematicFamily * KDL::readKinematicFamily ( std::istream & is )

reads the input stream and creates a KinematicFamily object

Parameters:

input stream

Returns:: a pointer to the created KinematicFamily object. The user is responsible for deleting this object.

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const std::vector< KinematicFamily * > &	chains
	)

writes the KinematicFamily object to an output stream.

Parameters:

	os	output stream
	chain	the KinematicFamily object that is to be written.

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const KinematicFamily *	chain
	)

writes the KinematicFamily object to an output stream.

Parameters:

	os	output stream
	chain	the KinematicFamily object that has to be written.

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const SerialChain *	chain
	)

writes the SerialChain object to an output stream.

Parameters:

	os	output stream
	chain	the SerialChain object that has to be written.

SerialChain * KDL::readSerialChain	(	std::istream &	is,
		bool	keyword = `true`
	)

reads the input stream and creates a SerialChain object

Parameters:

input stream

Returns:: a pointer to the created SerialChain object. The user is responsible for deleting this object.

Transmission * KDL::readTransmission ( std::istream & is )

reads the input stream and creates a Transmission object

Parameters:

input stream.

Returns:: a pointer to the created Transmission object. The user is responsible for deleting this object.

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const Transmission *	trans
	)

writes a Transmission oject to an output stream.

Parameters:

	os	output stream
	trans	the transmission object that has to be written.

This function should know about all implementations of Transmission.

ZXXZXZ * KDL::readZXXZXZ	(	std::istream &	is,
		bool	keyword = `true`
	)

reads the input stream and creates a zxxzxz object

Parameters:

input stream

Returns:: a pointer to the created zxxzxz object. The user is responsible for deleting this object.

std::ostream & KDL::operator<<	(	std::ostream &	os,
		const ZXXZXZ *	chain
	)

writes the zxxzxz object to an output stream.

Parameters:

	os	output stream
	chain	the zxxzxz object that has to be written.