KDL  1.4.0
Classes | Typedefs | Functions | Variables
KDL Namespace Reference

Classes

class  ArticulatedBodyInertia
 6D Inertia of a articulated body More...
 
class  Chain
 This class encapsulates a serial kinematic interconnection structure. More...
 
class  ChainDynParam
 Implementation of a method to calculate the matrices H (inertia),C(coriolis) and G(gravitation) for the calculation torques out of the pose and derivatives. More...
 
class  ChainFkSolverAcc
 This abstract class encapsulates a solver for the forward acceleration kinematics for a KDL::Chain. More...
 
class  ChainFkSolverPos
 This abstract class encapsulates a solver for the forward position kinematics for a KDL::Chain. More...
 
class  ChainFkSolverPos_recursive
 Implementation of a recursive forward position kinematics algorithm to calculate the position transformation from joint space to Cartesian space of a general kinematic chain (KDL::Chain). More...
 
class  ChainFkSolverVel
 This abstract class encapsulates a solver for the forward velocity kinematics for a KDL::Chain. More...
 
class  ChainFkSolverVel_recursive
 Implementation of a recursive forward position and velocity kinematics algorithm to calculate the position and velocity transformation from joint space to Cartesian space of a general kinematic chain (KDL::Chain). More...
 
class  ChainIdSolver
 This abstract class encapsulates the inverse dynamics solver for a KDL::Chain. More...
 
class  ChainIdSolver_RNE
 Recursive newton euler inverse dynamics solver. More...
 
class  ChainIdSolver_Vereshchagin
 Dynamics calculations by constraints based on Vereshchagin 1989. More...
 
class  ChainIkSolverAcc
 This abstract class encapsulates the inverse acceleration solver for a KDL::Chain. More...
 
class  ChainIkSolverPos
 This abstract class encapsulates the inverse position solver for a KDL::Chain. More...
 
class  ChainIkSolverPos_LMA
 Solver for the inverse position kinematics that uses Levenberg-Marquardt. More...
 
class  ChainIkSolverPos_NR
 Implementation of a general inverse position kinematics algorithm based on Newton-Raphson iterations to calculate the position transformation from Cartesian to joint space of a general KDL::Chain. More...
 
class  ChainIkSolverPos_NR_JL
 Implementation of a general inverse position kinematics algorithm based on Newton-Raphson iterations to calculate the position transformation from Cartesian to joint space of a general KDL::Chain. More...
 
class  ChainIkSolverVel
 This abstract class encapsulates the inverse velocity solver for a KDL::Chain. More...
 
class  ChainIkSolverVel_pinv
 Implementation of a inverse velocity kinematics algorithm based on the generalize pseudo inverse to calculate the velocity transformation from Cartesian to joint space of a general KDL::Chain. More...
 
class  ChainIkSolverVel_pinv_givens
 Implementation of a inverse velocity kinematics algorithm based on the generalize pseudo inverse to calculate the velocity transformation from Cartesian to joint space of a general KDL::Chain. More...
 
class  ChainIkSolverVel_pinv_nso
 Implementation of a inverse velocity kinematics algorithm based on the generalize pseudo inverse to calculate the velocity transformation from Cartesian to joint space of a general KDL::Chain. More...
 
class  ChainIkSolverVel_wdls
 Implementation of a inverse velocity kinematics algorithm based on the weighted pseudo inverse with damped least-square to calculate the velocity transformation from Cartesian to joint space of a general KDL::Chain. More...
 
class  ChainJntToJacDotSolver
 Computes the Jacobian time derivative (Jdot) by calculating the partial derivatives regarding to a joint angle, in the Hybrid, Body-fixed or Inertial representation. More...
 
class  ChainJntToJacSolver
 Class to calculate the jacobian of a general KDL::Chain, it is used by other solvers. More...
 
class  Frame
 represents a frame transformation in 3D space (rotation + translation) More...
 
class  Frame2
 A 2D frame class, for further documentation see the Frames class for methods with unchanged semantics. More...
 
class  FrameAcc
 
class  FrameVel
 
class  Jacobian
 
class  JntArray
 This class represents an fixed size array containing joint values of a KDL::Chain. More...
 
class  JntArrayAcc
 
class  JntArrayVel
 
class  Joint
 This class encapsulates a simple joint, that is with one parameterized degree of freedom and with scalar dynamic properties. 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  RigidBodyInertia
 6D Inertia of a rigid body More...
 
class  Rotation
 represents rotations in 3 dimensional space. More...
 
class  Rotation2
 A 2D Rotation class, for conventions see Rotation. More...
 
class  RotationAcc
 
class  RotationalInertia
 
class  RotationalInterpolation
 RotationalInterpolation specifies the rotational part of a geometric trajectory. 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  RotationVel
 
class  Segment
 This class encapsulates a simple segment, that is a "rigid body" (i.e., a frame and a rigid body inertia) with a joint and with "handles", root and tip to connect to other segments. More...
 
class  SolverI
 Solver interface supporting storage and description of the latest error. More...
 
class  Stiffness
 Preliminary class to implement Stiffness, only diagonal stiffness is implemented no transformations provided... More...
 
class  Trajectory
 An abstract class that implements a trajectory contains a cartesian space trajectory and an underlying velocity profile. More...
 
class  Trajectory_Composite
 Trajectory_Composite implements a trajectory that is composed of underlying trajectoria. More...
 
class  Trajectory_Segment
 Trajectory_Segment combines a VelocityProfile and a Path into a trajectory. More...
 
class  Trajectory_Stationary
 Implements a "trajectory" of a stationary position for an amount of time. More...
 
class  Tree
 This class encapsulates a tree kinematic interconnection structure. More...
 
class  TreeElement
 
class  TreeFkSolverPos
 This abstract class encapsulates a solver for the forward position kinematics for a KDL::Tree. More...
 
class  TreeFkSolverPos_recursive
 Implementation of a recursive forward position kinematics algorithm to calculate the position transformation from joint space to Cartesian space of a general kinematic tree (KDL::Tree). More...
 
class  TreeIkSolverPos
 This abstract class encapsulates the inverse position solver for a KDL::Chain. More...
 
class  TreeIkSolverPos_NR_JL
 Implementation of a general inverse position kinematics algorithm based on Newton-Raphson iterations to calculate the position transformation from Cartesian to joint space of a general KDL::Tree. More...
 
class  TreeIkSolverPos_Online
 Implementation of a general inverse position kinematics algorithm to calculate the position transformation from Cartesian to joint space of a general KDL::Tree. More...
 
class  TreeIkSolverVel
 This abstract class encapsulates the inverse velocity solver for a KDL::Tree. More...
 
class  TreeIkSolverVel_wdls
 
class  TreeJntToJacSolver
 
class  Twist
 represents both translational and rotational velocities. More...
 
class  TwistAcc
 
class  TwistVel
 
class  Vector
 A concrete implementation of a 3 dimensional vector class. More...
 
class  Vector2
 2D version of Vector More...
 
class  VectorAcc
 
class  VectorVel
 
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_Spline
 A spline VelocityProfile trajectory interpolation. More...
 
class  VelocityProfile_Trap
 A Trapezoidal VelocityProfile implementation. More...
 
class  VelocityProfile_TrapHalf
 A 'Half' Trapezoidal VelocityProfile. More...
 
class  Wrench
 represents both translational and rotational acceleration. More...
 

Typedefs

typedef std::vector< WrenchWrenches
 
typedef Rall2d< double, double, double > doubleAcc
 
typedef Rall1d< double > doubleVel
 
typedef std::map< std::string, TreeElementSegmentMap
 
typedef TreeElement TreeElementType
 
typedef std::map< std::string, TwistTwists
 
typedef std::map< std::string, JacobianJacobians
 
typedef std::map< std::string, FrameFrames
 

Functions

ArticulatedBodyInertia operator* (double a, const ArticulatedBodyInertia &I)
 Scalar product: I_new = double * I_old. More...
 
ArticulatedBodyInertia operator+ (const ArticulatedBodyInertia &Ia, const ArticulatedBodyInertia &Ib)
 addition I: I_new = I_old1 + I_old2, make sure that I_old1 and I_old2 are expressed in the same reference frame/point, otherwise the result is worth nothing More...
 
ArticulatedBodyInertia operator+ (const RigidBodyInertia &Ia, const ArticulatedBodyInertia &Ib)
 
ArticulatedBodyInertia operator- (const ArticulatedBodyInertia &Ia, const ArticulatedBodyInertia &Ib)
 
ArticulatedBodyInertia operator- (const RigidBodyInertia &Ia, const ArticulatedBodyInertia &Ib)
 
Wrench operator* (const ArticulatedBodyInertia &I, const Twist &t)
 calculate spatial momentum: h = I*v make sure that the twist v and the inertia are expressed in the same reference frame/point More...
 
ArticulatedBodyInertia operator* (const Frame &T, const ArticulatedBodyInertia &I)
 Coordinate system transform Ia = T_a_b*Ib with T_a_b the frame from a to b. More...
 
ArticulatedBodyInertia operator* (const Rotation &R, const ArticulatedBodyInertia &I)
 Reference frame orientation change Ia = R_a_b*Ib with R_a_b the rotation of b expressed in a. More...
 
ArticulatedBodyInertia operator+ (const ArticulatedBodyInertia &Ia, const RigidBodyInertia &Ib)
 
ArticulatedBodyInertia operator- (const ArticulatedBodyInertia &Ia, const RigidBodyInertia &Ib)
 
template<typename Derived >
void Twist_to_Eigen (const KDL::Twist &t, Eigen::MatrixBase< Derived > &e)
 
IMETHOD bool Equal (const FrameAcc &r1, const FrameAcc &r2, double eps=epsilon)
 
IMETHOD bool Equal (const Frame &r1, const FrameAcc &r2, double eps=epsilon)
 
IMETHOD bool Equal (const FrameAcc &r1, const Frame &r2, double eps=epsilon)
 
IMETHOD bool Equal (const RotationAcc &r1, const RotationAcc &r2, double eps=epsilon)
 
IMETHOD bool Equal (const Rotation &r1, const RotationAcc &r2, double eps=epsilon)
 
IMETHOD bool Equal (const RotationAcc &r1, const Rotation &r2, double eps=epsilon)
 
IMETHOD bool Equal (const TwistAcc &a, const TwistAcc &b, double eps=epsilon)
 
IMETHOD bool Equal (const Twist &a, const TwistAcc &b, double eps=epsilon)
 
IMETHOD bool Equal (const TwistAcc &a, const Twist &b, double eps=epsilon)
 
IMETHOD bool Equal (const VectorAcc &r1, const VectorAcc &r2, double eps=epsilon)
 
IMETHOD bool Equal (const Vector &r1, const VectorAcc &r2, double eps=epsilon)
 
IMETHOD bool Equal (const VectorAcc &r1, const Vector &r2, double eps=epsilon)
 
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)
 
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)
 
FrameAcc operator* (const FrameAcc &lhs, const FrameAcc &rhs)
 
FrameAcc operator* (const FrameAcc &lhs, const Frame &rhs)
 
FrameAcc operator* (const Frame &lhs, const FrameAcc &rhs)
 
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)
 
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)
 
bool Equal (const Vector &a, const Vector &b, double eps=epsilon)
 
bool Equal (const Frame &a, const Frame &b, double eps=epsilon)
 
bool Equal (const Twist &a, const Twist &b, double eps=epsilon)
 
bool Equal (const Wrench &a, const Wrench &b, double eps=epsilon)
 
bool Equal (const Vector2 &a, const Vector2 &b, double eps=epsilon)
 
bool Equal (const Rotation2 &a, const Rotation2 &b, double eps=epsilon)
 
bool Equal (const Frame2 &a, const Frame2 &b, double eps=epsilon)
 
IMETHOD Vector 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 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 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 diff (const Twist &a, const Twist &b, double dt=1)
 determines the difference between two twists i.e. More...
 
IMETHOD Wrench 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 addDelta (const Vector &p_w_a, const Vector &p_w_da, double dt=1)
 adds vector da to vector a. More...
 
IMETHOD Rotation 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 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 addDelta (const Twist &a, const Twist &da, double dt=1)
 adds the twist da to the twist a. More...
 
IMETHOD Wrench addDelta (const Wrench &a, const Wrench &da, double dt=1)
 adds the wrench da to the wrench w. More...
 
IMETHOD Vector operator+ (const Vector &lhs, const Vector &rhs)
 
IMETHOD Vector operator- (const Vector &lhs, const Vector &rhs)
 
Vector operator* (const Vector &lhs, double rhs)
 
Vector operator* (double lhs, const Vector &rhs)
 
Vector operator/ (const Vector &lhs, double rhs)
 
Vector operator* (const Vector &lhs, const Vector &rhs)
 
Wrench operator* (const Wrench &lhs, double rhs)
 
Wrench operator* (double lhs, const Wrench &rhs)
 
Wrench operator/ (const Wrench &lhs, double rhs)
 
Wrench operator+ (const Wrench &lhs, const Wrench &rhs)
 
Wrench operator- (const Wrench &lhs, const Wrench &rhs)
 
Wrench operator- (const Wrench &arg)
 
Twist operator* (const Twist &lhs, double rhs)
 
Twist operator* (double lhs, const Twist &rhs)
 
Twist operator/ (const Twist &lhs, double rhs)
 
Twist operator+ (const Twist &lhs, const Twist &rhs)
 
Twist operator- (const Twist &lhs, const Twist &rhs)
 
Twist operator- (const Twist &arg)
 
Twist operator* (const Twist &lhs, const Twist &rhs)
 
Wrench operator* (const Twist &lhs, const Wrench &rhs)
 
Frame operator* (const Frame &lhs, const Frame &rhs)
 
Vector operator- (const Vector &arg)
 
IMETHOD Vector2 operator+ (const Vector2 &lhs, const Vector2 &rhs)
 
IMETHOD Vector2 operator- (const Vector2 &lhs, const Vector2 &rhs)
 
IMETHOD Vector2 operator* (const Vector2 &lhs, double rhs)
 
IMETHOD Vector2 operator* (double lhs, const Vector2 &rhs)
 
IMETHOD Vector2 operator/ (const Vector2 &lhs, double rhs)
 
IMETHOD Vector2 operator- (const Vector2 &arg)
 
IMETHOD Rotation2 operator* (const Rotation2 &lhs, const Rotation2 &rhs)
 
IMETHOD Frame2 operator* (const Frame2 &lhs, const Frame2 &rhs)
 
IMETHOD double dot (const Vector &lhs, const Vector &rhs)
 
IMETHOD double dot (const Twist &lhs, const Wrench &rhs)
 
IMETHOD double dot (const Wrench &rhs, const Twist &lhs)
 
IMETHOD void SetToZero (Vector &v)
 
IMETHOD void SetToZero (Twist &v)
 
IMETHOD void SetToZero (Wrench &v)
 
IMETHOD void SetToZero (Vector2 &v)
 
IMETHOD Rotation 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 random (Vector &a)
 addDelta operator for displacement rotational velocity. More...
 
IMETHOD void random (Twist &a)
 
IMETHOD void random (Wrench &a)
 
IMETHOD void random (Rotation &R)
 
IMETHOD void random (Frame &F)
 
IMETHOD void posrandom (Vector &a)
 
IMETHOD void posrandom (Twist &a)
 
IMETHOD void posrandom (Wrench &a)
 
IMETHOD void posrandom (Rotation &R)
 
IMETHOD void posrandom (Frame &F)
 
IMETHOD bool operator== (const Frame &a, const Frame &b)
 
IMETHOD bool operator!= (const Frame &a, const Frame &b)
 
IMETHOD bool operator== (const Vector &a, const Vector &b)
 
IMETHOD bool operator!= (const Vector &a, const Vector &b)
 
IMETHOD bool operator== (const Twist &a, const Twist &b)
 
IMETHOD bool operator!= (const Twist &a, const Twist &b)
 
IMETHOD bool operator== (const Wrench &a, const Wrench &b)
 
IMETHOD bool operator!= (const Wrench &a, const Wrench &b)
 
IMETHOD bool operator!= (const Rotation &a, const Rotation &b)
 
IMETHOD bool operator== (const Vector2 &a, const Vector2 &b)
 
IMETHOD bool operator!= (const Vector2 &a, const Vector2 &b)
 
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. More...
 
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 bool Equal (const VectorVel &r1, const VectorVel &r2, double eps=epsilon)
 
IMETHOD bool Equal (const Vector &r1, const VectorVel &r2, double eps=epsilon)
 
IMETHOD bool Equal (const VectorVel &r1, const Vector &r2, double eps=epsilon)
 
IMETHOD bool Equal (const RotationVel &r1, const RotationVel &r2, double eps=epsilon)
 
IMETHOD bool Equal (const Rotation &r1, const RotationVel &r2, double eps=epsilon)
 
IMETHOD bool Equal (const RotationVel &r1, const Rotation &r2, double eps=epsilon)
 
IMETHOD bool Equal (const FrameVel &r1, const FrameVel &r2, double eps=epsilon)
 
IMETHOD bool Equal (const Frame &r1, const FrameVel &r2, double eps=epsilon)
 
IMETHOD bool Equal (const FrameVel &r1, const Frame &r2, double eps=epsilon)
 
IMETHOD bool Equal (const TwistVel &a, const TwistVel &b, double eps=epsilon)
 
IMETHOD bool Equal (const Twist &a, const TwistVel &b, double eps=epsilon)
 
IMETHOD bool Equal (const TwistVel &a, const Twist &b, double eps=epsilon)
 
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)
 
FrameVel operator* (const FrameVel &lhs, const FrameVel &rhs)
 
FrameVel operator* (const FrameVel &lhs, const Frame &rhs)
 
FrameVel operator* (const Frame &lhs, const FrameVel &rhs)
 
RotationVel operator* (const RotationVel &r1, const RotationVel &r2)
 
RotationVel operator* (const Rotation &r1, const RotationVel &r2)
 
RotationVel operator* (const RotationVel &r1, const Rotation &r2)
 
VectorVel operator+ (const VectorVel &r1, const VectorVel &r2)
 
VectorVel operator- (const VectorVel &r1, const VectorVel &r2)
 
VectorVel operator+ (const VectorVel &r1, const Vector &r2)
 
VectorVel operator- (const VectorVel &r1, const Vector &r2)
 
VectorVel operator+ (const Vector &r1, const VectorVel &r2)
 
VectorVel operator- (const Vector &r1, const VectorVel &r2)
 
VectorVel operator- (const VectorVel &r)
 
void SetToZero (VectorVel &v)
 
VectorVel operator* (const VectorVel &r1, const VectorVel &r2)
 
VectorVel operator* (const VectorVel &r1, const Vector &r2)
 
VectorVel operator* (const Vector &r1, const VectorVel &r2)
 
VectorVel operator* (double r1, const VectorVel &r2)
 
VectorVel operator* (const VectorVel &r1, double r2)
 
VectorVel operator* (const doubleVel &r1, const VectorVel &r2)
 
VectorVel operator* (const VectorVel &r2, const doubleVel &r1)
 
VectorVel operator/ (const VectorVel &r1, double r2)
 
VectorVel operator/ (const VectorVel &r2, const doubleVel &r1)
 
VectorVel operator* (const Rotation &R, const VectorVel &x)
 
IMETHOD doubleVel dot (const VectorVel &lhs, const VectorVel &rhs)
 
IMETHOD doubleVel dot (const VectorVel &lhs, const Vector &rhs)
 
IMETHOD doubleVel dot (const Vector &lhs, const VectorVel &rhs)
 
TwistVel operator* (const TwistVel &lhs, double rhs)
 
TwistVel operator* (double lhs, const TwistVel &rhs)
 
TwistVel operator/ (const TwistVel &lhs, double rhs)
 
TwistVel operator* (const TwistVel &lhs, const doubleVel &rhs)
 
TwistVel operator* (const doubleVel &lhs, const TwistVel &rhs)
 
TwistVel operator/ (const TwistVel &lhs, const doubleVel &rhs)
 
TwistVel operator+ (const TwistVel &lhs, const TwistVel &rhs)
 
TwistVel operator- (const TwistVel &lhs, const TwistVel &rhs)
 
TwistVel operator- (const TwistVel &arg)
 
void SetToZero (TwistVel &v)
 
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)
 
void SetToZero (Jacobian &jac)
 
bool changeRefPoint (const Jacobian &src1, const Vector &base_AB, Jacobian &dest)
 
bool changeBase (const Jacobian &src1, const Rotation &rot, Jacobian &dest)
 
bool changeRefFrame (const Jacobian &src1, const Frame &frame, Jacobian &dest)
 
bool Equal (const Jacobian &a, const Jacobian &b, double eps)
 
void Add (const JntArray &src1, const JntArray &src2, JntArray &dest)
 Function to add two joint arrays, all the arguments must have the same size: A + B = C. More...
 
void Subtract (const JntArray &src1, const JntArray &src2, JntArray &dest)
 Function to subtract two joint arrays, all the arguments must have the same size: A - B = C. More...
 
void Multiply (const JntArray &src, const double &factor, JntArray &dest)
 Function to multiply all the array values with a scalar factor: A*b=C. More...
 
void Divide (const JntArray &src, const double &factor, JntArray &dest)
 Function to divide all the array values with a scalar factor: A/b=C. More...
 
void MultiplyJacobian (const Jacobian &jac, const JntArray &src, Twist &dest)
 Function to multiply a KDL::Jacobian with a KDL::JntArray to get a KDL::Twist, it should not be used to calculate the forward velocity kinematics, the solver classes are built for this purpose. More...
 
void SetToZero (JntArray &array)
 Function to set all the values of the array to 0. More...
 
bool Equal (const JntArray &src1, const JntArray &src2, double eps=epsilon)
 Function to check if two arrays are the same with a precision of eps. More...
 
bool operator== (const JntArray &src1, const JntArray &src2)
 
void Add (const JntArrayAcc &src1, const JntArrayAcc &src2, JntArrayAcc &dest)
 
void Add (const JntArrayAcc &src1, const JntArrayVel &src2, JntArrayAcc &dest)
 
void Add (const JntArrayAcc &src1, const JntArray &src2, JntArrayAcc &dest)
 
void Subtract (const JntArrayAcc &src1, const JntArrayAcc &src2, JntArrayAcc &dest)
 
void Subtract (const JntArrayAcc &src1, const JntArrayVel &src2, JntArrayAcc &dest)
 
void Subtract (const JntArrayAcc &src1, const JntArray &src2, JntArrayAcc &dest)
 
void Multiply (const JntArrayAcc &src, const double &factor, JntArrayAcc &dest)
 
void Multiply (const JntArrayAcc &src, const doubleVel &factor, JntArrayAcc &dest)
 
void Multiply (const JntArrayAcc &src, const doubleAcc &factor, JntArrayAcc &dest)
 
void Divide (const JntArrayAcc &src, const double &factor, JntArrayAcc &dest)
 
void Divide (const JntArrayAcc &src, const doubleVel &factor, JntArrayAcc &dest)
 
void Divide (const JntArrayAcc &src, const doubleAcc &factor, JntArrayAcc &dest)
 
void SetToZero (JntArrayAcc &array)
 
bool Equal (const JntArrayAcc &src1, const JntArrayAcc &src2, double eps)
 
void Add (const JntArrayVel &src1, const JntArrayVel &src2, JntArrayVel &dest)
 
void Add (const JntArrayVel &src1, const JntArray &src2, JntArrayVel &dest)
 
void Subtract (const JntArrayVel &src1, const JntArrayVel &src2, JntArrayVel &dest)
 
void Subtract (const JntArrayVel &src1, const JntArray &src2, JntArrayVel &dest)
 
void Multiply (const JntArrayVel &src, const double &factor, JntArrayVel &dest)
 
void Multiply (const JntArrayVel &src, const doubleVel &factor, JntArrayVel &dest)
 
void Divide (const JntArrayVel &src, const double &factor, JntArrayVel &dest)
 
void Divide (const JntArrayVel &src, const doubleVel &factor, JntArrayVel &dest)
 
void SetToZero (JntArrayVel &array)
 
bool Equal (const JntArrayVel &src1, const JntArrayVel &src2, double eps)
 
void Add (const JntSpaceInertiaMatrix &src1, const JntSpaceInertiaMatrix &src2, JntSpaceInertiaMatrix &dest)
 
void Subtract (const JntSpaceInertiaMatrix &src1, const JntSpaceInertiaMatrix &src2, JntSpaceInertiaMatrix &dest)
 
void Multiply (const JntSpaceInertiaMatrix &src, const double &factor, JntSpaceInertiaMatrix &dest)
 
void Divide (const JntSpaceInertiaMatrix &src, const double &factor, JntSpaceInertiaMatrix &dest)
 
void Multiply (const JntSpaceInertiaMatrix &src, const JntArray &vec, JntArray &dest)
 
void SetToZero (JntSpaceInertiaMatrix &mat)
 
bool Equal (const JntSpaceInertiaMatrix &src1, const JntSpaceInertiaMatrix &src2, double eps)
 
bool operator== (const JntSpaceInertiaMatrix &src1, const JntSpaceInertiaMatrix &src2)
 
std::ostream & operator<< (std::ostream &os, const Joint &joint)
 
std::istream & operator>> (std::istream &is, Joint &joint)
 
std::ostream & operator<< (std::ostream &os, const Segment &segment)
 
std::istream & operator>> (std::istream &is, Segment &segment)
 
std::ostream & operator<< (std::ostream &os, const Chain &chain)
 
std::istream & operator>> (std::istream &is, Chain &chain)
 
std::ostream & operator<< (std::ostream &os, const Tree &tree)
 
std::ostream & operator<< (std::ostream &os, SegmentMap::const_iterator root)
 
std::istream & operator>> (std::istream &is, Tree &tree)
 
std::ostream & operator<< (std::ostream &os, const JntArray &array)
 
std::istream & operator>> (std::istream &is, JntArray &array)
 
std::ostream & operator<< (std::ostream &os, const Jacobian &jac)
 
std::istream & operator>> (std::istream &is, Jacobian &jac)
 
std::ostream & operator<< (std::ostream &os, const JntSpaceInertiaMatrix &jntspaceinertiamatrix)
 
std::istream & operator>> (std::istream &is, JntSpaceInertiaMatrix &jntspaceinertiamatrix)
 
RigidBodyInertia operator* (double a, const RigidBodyInertia &I)
 Scalar product: I_new = double * I_old. More...
 
RigidBodyInertia operator+ (const RigidBodyInertia &Ia, const RigidBodyInertia &Ib)
 addition I: I_new = I_old1 + I_old2, make sure that I_old1 and I_old2 are expressed in the same reference frame/point, otherwise the result is worth nothing More...
 
Wrench operator* (const RigidBodyInertia &I, const Twist &t)
 calculate spatial momentum: h = I*v make sure that the twist v and the inertia are expressed in the same reference frame/point More...
 
RigidBodyInertia operator* (const Frame &T, const RigidBodyInertia &I)
 Coordinate system transform Ia = T_a_b*Ib with T_a_b the frame from a to b. More...
 
RigidBodyInertia operator* (const Rotation &R, const RigidBodyInertia &I)
 Reference frame orientation change Ia = R_a_b*Ib with R_a_b the rotation of b expressed in a. More...
 
RotationalInertia operator* (double a, const RotationalInertia &I)
 
RotationalInertia operator+ (const RotationalInertia &Ia, const RotationalInertia &Ib)
 
Wrench operator* (const Stiffness &s, const Twist &t)
 
Stiffness operator+ (const Stiffness &s1, const Stiffness &s2)
 
void posrandom (Stiffness &F)
 
void random (Stiffness &F)
 
static void generatePowers (int n, double x, double *powers)
 
int svd_eigen_Macie (const MatrixXd &A, MatrixXd &U, VectorXd &S, MatrixXd &V, MatrixXd &B, VectorXd &tempi, double threshold, bool toggle)
 svd_eigen_Macie provides Maciejewski implementation for SVD. More...
 

Variables

static const bool mhi =true
 

Typedef Documentation

§ doubleAcc

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

§ doubleVel

typedef Rall1d<double> KDL::doubleVel

§ Frames

typedef std::map<std::string, Frame> KDL::Frames

§ Jacobians

typedef std::map<std::string, Jacobian> KDL::Jacobians

§ SegmentMap

typedef std::map<std::string,TreeElement> KDL::SegmentMap

§ TreeElementType

§ Twists

typedef std::map<std::string, Twist> KDL::Twists

§ Wrenches

typedef std::vector<Wrench> KDL::Wrenches

Function Documentation

§ Add() [1/7]

void KDL::Add ( const JntArrayVel src1,
const JntArrayVel src2,
JntArrayVel dest 
)

§ Add() [2/7]

void KDL::Add ( const JntArrayVel src1,
const JntArray src2,
JntArrayVel dest 
)

§ Add() [3/7]

void KDL::Add ( const JntArrayAcc src1,
const JntArrayAcc src2,
JntArrayAcc dest 
)

§ Add() [4/7]

void KDL::Add ( const JntArrayAcc src1,
const JntArrayVel src2,
JntArrayAcc dest 
)

§ Add() [5/7]

void KDL::Add ( const JntArrayAcc src1,
const JntArray src2,
JntArrayAcc dest 
)

§ Add() [6/7]

void KDL::Add ( const JntSpaceInertiaMatrix &  src1,
const JntSpaceInertiaMatrix &  src2,
JntSpaceInertiaMatrix &  dest 
)

§ Add() [7/7]

void KDL::Add ( const JntArray src1,
const JntArray src2,
JntArray dest 
)

Function to add two joint arrays, all the arguments must have the same size: A + B = C.

This function is aliasing-safe, A or B can be the same array as C.

Parameters
src1A
src2B
destC

References KDL::JntArray::data.

Referenced by KDL::TreeIkSolverPos_NR_JL::CartToJnt(), KDL::ChainIkSolverPos_NR::CartToJnt(), KDL::TreeIkSolverPos_Online::CartToJnt(), and KDL::ChainIkSolverPos_NR_JL::CartToJnt().

§ addDelta() [1/9]

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

§ addDelta() [2/9]

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

§ addDelta() [3/9]

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

§ addDelta() [4/9]

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

§ addDelta() [5/9]

IMETHOD Vector KDL::addDelta ( const Vector p_w_a,
const Vector p_w_da,
double  dt = 1 
)

adds vector da to vector a.

see also the corresponding diff() routine.

Parameters
p_w_avector a expressed to some frame w.
p_w_davector da expressed to some frame w.
Returns
the vector resulting from the displacement of vector a by vector da, expressed in the frame w.

Referenced by Equal().

§ addDelta() [6/9]

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.

see also the corresponding diff() routine.

Parameters
R_w_aRotation matrix of frame a expressed to some frame w.
da_waxis and angle of the rotation expressed to some frame w.
Returns
the rotation matrix resulting from the rotation of frame a by the axis and angle specified with da. The resulting rotation matrix is expressed with respect to frame w.

§ addDelta() [7/9]

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).

see also the corresponding diff() routine.

Parameters
R_w_aRotation matrix of frame a expressed to some frame w.
da_waxis and angle of the rotation (da_w.rot), together with a displacement vector for the origin (da_w.vel), expressed to some frame w.
Returns
the frame resulting from the rotation of frame a by the axis and angle specified with da.rot, and the translation of the origin da_w.vel . The resulting frame is expressed with respect to frame w.

§ addDelta() [8/9]

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

adds the twist da to the twist a.

see also the corresponding diff() routine.

Parameters
aa twist wrt some frame
daa twist difference wrt some frame
Returns
The twist (a+da) wrt the corresponding frame.

§ addDelta() [9/9]

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

adds the wrench da to the wrench w.

see also the corresponding diff() routine. see also the corresponding diff() routine.

Parameters
aa wrench wrt some frame
daa wrench difference wrt some frame
Returns
the wrench (a+da) wrt the corresponding frame.

§ changeBase()

bool KDL::changeBase ( const Jacobian src1,
const Rotation rot,
Jacobian dest 
)

§ changeRefFrame()

bool KDL::changeRefFrame ( const Jacobian src1,
const Frame frame,
Jacobian dest 
)

§ changeRefPoint()

bool KDL::changeRefPoint ( const Jacobian src1,
const Vector base_AB,
Jacobian dest 
)

§ diff() [1/9]

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

§ diff() [2/9]

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

§ diff() [3/9]

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

§ diff() [4/9]

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

§ diff() [5/9]

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.

see diff for Rotation matrices for further background information.

Parameters
p_w_astart vector a expressed to some frame w
p_w_bend vector b expressed to some frame w .
dt[optional][obsolete] time interval over which the numerical differentiation takes place.
Returns
the difference (b-a) expressed to the frame w.

Referenced by KDL::TreeIkSolverPos_NR_JL::CartToJnt(), KDL::ChainIkSolverPos_NR::CartToJnt(), KDL::TreeIkSolverPos_Online::CartToJnt(), KDL::ChainIkSolverPos_NR_JL::CartToJnt(), KDL::ChainIkSolverPos_LMA::CartToJnt(), diff(), Equal(), KDL::VelocityProfile_Rectangular::SetProfile(), and KDL::VelocityProfile_Rectangular::SetProfileDuration().

§ diff() [6/9]

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.

This rotation axis is expressed w.r.t. frame a. The rotation axis is scaled by the necessary rotation angle. The rotation angle is always in the (inclusive) interval \( [0 , \pi] \).

This definition is chosen in this way to facilitate numerical differentiation. With this definition diff(a,b) == -diff(b,a).

The diff() function is overloaded for all classes in frames.hpp and framesvel.hpp, such that numerical differentiation, equality checks with tolerances, etc. can be performed without caring exactly on which type the operation is performed.

Parameters
R_a_b1The rotation matrix \( _a^{b1} R \) of b1 with respect to frame a.
R_a_b2The Rotation matrix \( _a^{b2} R \) of b2 with respect to frame a.
dt[optional][obsolete] time interval over which the numerical differentiation takes place. By default this is set to 1.0.
Returns
rotation axis to rotate from b1 to b2, scaled by the rotation angle, expressed in frame a.
Warning
- The result is not a rotational vector, i.e. it is not a mathematical vector. (no communitative addition).
- When used in the context of numerical differentiation, with the frames b1 and b2 very close to each other, the semantics correspond to the twist, scaled by the time.
- For angles equal to \( \pi \), The negative of the return value is equally valid.

§ diff() [7/9]

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.

Parameters
F_a_b1frame b1 expressed with respect to some frame a.
F_a_b2frame b2 expressed with respect to some frame a.
Warning
The result is not a Twist! see diff() for Rotation and Vector arguments for further detail on the semantics.

§ diff() [8/9]

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

determines the difference between two twists i.e.

the difference between the underlying velocity vectors and rotational velocity vectors.

§ diff() [9/9]

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.

the difference between the underlying torque vectors and force vectors.

§ Divide() [1/7]

void KDL::Divide ( const JntArrayVel src,
const double &  factor,
JntArrayVel dest 
)

§ Divide() [2/7]

void KDL::Divide ( const JntSpaceInertiaMatrix &  src,
const double &  factor,
JntSpaceInertiaMatrix &  dest 
)

§ Divide() [3/7]

void KDL::Divide ( const JntArrayVel src,
const doubleVel factor,
JntArrayVel dest 
)

§ Divide() [4/7]

void KDL::Divide ( const JntArray src,
const double &  factor,
JntArray dest 
)

Function to divide all the array values with a scalar factor: A/b=C.

This function is aliasing-safe, A can be the same array as C.

Parameters
srcA
factorb
destC

References KDL::JntArray::data.

§ Divide() [5/7]

void KDL::Divide ( const JntArrayAcc src,
const double &  factor,
JntArrayAcc dest 
)

§ Divide() [6/7]

void KDL::Divide ( const JntArrayAcc src,
const doubleVel factor,
JntArrayAcc dest 
)

§ Divide() [7/7]

void KDL::Divide ( const JntArrayAcc src,
const doubleAcc factor,
JntArrayAcc dest 
)

§ dot() [1/9]

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

§ dot() [2/9]

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

§ dot() [3/9]

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

§ dot() [4/9]

IMETHOD doubleVel KDL::dot ( const VectorVel lhs,
const VectorVel rhs 
)

§ dot() [5/9]

IMETHOD doubleVel KDL::dot ( const VectorVel lhs,
const Vector rhs 
)

§ dot() [6/9]

IMETHOD doubleVel KDL::dot ( const Vector lhs,
const VectorVel rhs 
)

§ dot() [7/9]

IMETHOD double KDL::dot ( const Vector lhs,
const Vector rhs 
)

§ dot() [8/9]

IMETHOD double KDL::dot ( const Twist lhs,
const Wrench rhs 
)

§ dot() [9/9]

IMETHOD double KDL::dot ( const Wrench rhs,
const Twist lhs 
)

§ Equal() [1/37]

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

§ Equal() [2/37]

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

§ Equal() [3/37]

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

§ Equal() [4/37]

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

§ Equal() [5/37]

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

§ Equal() [6/37]

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

§ Equal() [7/37]

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

§ Equal() [8/37]

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

§ Equal() [9/37]

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

§ Equal() [10/37]

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

§ Equal() [11/37]

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

§ Equal() [12/37]

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

§ Equal() [13/37]

bool KDL::Equal ( const VectorVel r1,
const VectorVel r2,
double  eps = epsilon 
)

§ Equal() [14/37]

bool KDL::Equal ( const Vector r1,
const VectorVel r2,
double  eps = epsilon 
)

§ Equal() [15/37]

bool KDL::Equal ( const VectorVel r1,
const Vector r2,
double  eps = epsilon 
)

§ Equal() [16/37]

bool KDL::Equal ( const RotationVel r1,
const RotationVel r2,
double  eps = epsilon 
)

§ Equal() [17/37]

bool KDL::Equal ( const Rotation r1,
const RotationVel r2,
double  eps = epsilon 
)

§ Equal() [18/37]

bool KDL::Equal ( const RotationVel r1,
const Rotation r2,
double  eps = epsilon 
)

§ Equal() [19/37]

bool KDL::Equal ( const FrameVel r1,
const FrameVel r2,
double  eps = epsilon 
)

§ Equal() [20/37]

bool KDL::Equal ( const Frame r1,
const FrameVel r2,
double  eps = epsilon 
)

§ Equal() [21/37]

bool KDL::Equal ( const FrameVel r1,
const Frame r2,
double  eps = epsilon 
)

§ Equal() [22/37]

bool KDL::Equal ( const TwistVel a,
const TwistVel b,
double  eps = epsilon 
)

§ Equal() [23/37]

bool KDL::Equal ( const Twist a,
const TwistVel b,
double  eps = epsilon 
)

§ Equal() [24/37]

bool KDL::Equal ( const TwistVel a,
const Twist b,
double  eps = epsilon 
)

§ Equal() [25/37]

bool KDL::Equal ( const JntArrayVel src1,
const JntArrayVel src2,
double  eps 
)

§ Equal() [26/37]

bool KDL::Equal ( const JntSpaceInertiaMatrix &  src1,
const JntSpaceInertiaMatrix &  src2,
double  eps 
)

§ Equal() [27/37]

bool KDL::Equal ( const JntArray src1,
const JntArray src2,
double  eps = epsilon 
)

Function to check if two arrays are the same with a precision of eps.

Parameters
src1
src2
epsdefault: epsilon
Returns
true if each element of src1 is within eps of the same element in src2, or if both src1 and src2 have no data (ie 0==rows())

References KDL::JntArray::data, and KDL::JntArray::rows().

§ Equal() [28/37]

bool KDL::Equal ( const Jacobian a,
const Jacobian b,
double  eps 
)

§ Equal() [29/37]

IMETHOD bool KDL::Equal ( const Vector a,
const Vector b,
double  eps = epsilon 
)
inline

It compares whether the 2 arguments are equal in an eps-interval

§ Equal() [30/37]

IMETHOD bool KDL::Equal ( const Frame a,
const Frame b,
double  eps = epsilon 
)
inline

It compares whether the 2 arguments are equal in an eps-interval

§ Equal() [31/37]

IMETHOD bool KDL::Equal ( const Twist a,
const Twist b,
double  eps = epsilon 
)
inline

It compares whether the 2 arguments are equal in an eps-interval

§ Equal() [32/37]

IMETHOD bool KDL::Equal ( const Wrench a,
const Wrench b,
double  eps = epsilon 
)
inline

It compares whether the 2 arguments are equal in an eps-interval

§ Equal() [33/37]

IMETHOD bool KDL::Equal ( const Vector2 a,
const Vector2 b,
double  eps = epsilon 
)
inline

It compares whether the 2 arguments are equal in an eps-interval

§ Equal() [34/37]

IMETHOD bool KDL::Equal ( const Rotation2 a,
const Rotation2 b,
double  eps = epsilon 
)
inline

It compares whether the 2 arguments are equal in an eps-interval

§ Equal() [35/37]

IMETHOD bool KDL::Equal ( const Frame2 a,
const Frame2 b,
double  eps = epsilon 
)
inline

§ Equal() [36/37]

bool KDL::Equal ( const Rotation a,
const Rotation b,
double  eps 
)

It compares whether the 2 arguments are equal in an eps-interval

References KDL::Rotation::data, and KDL::Frame::Equal.

§ Equal() [37/37]

bool KDL::Equal ( const JntArrayAcc src1,
const JntArrayAcc src2,
double  eps 
)

§ generatePowers()

static void KDL::generatePowers ( int  n,
double  x,
double *  powers 
)
inlinestatic

§ Multiply() [1/8]

void KDL::Multiply ( const JntArrayVel src,
const double &  factor,
JntArrayVel dest 
)

§ Multiply() [2/8]

void KDL::Multiply ( const JntArrayVel src,
const doubleVel factor,
JntArrayVel dest 
)

§ Multiply() [3/8]

void KDL::Multiply ( const JntSpaceInertiaMatrix &  src,
const double &  factor,
JntSpaceInertiaMatrix &  dest 
)

§ Multiply() [4/8]

void KDL::Multiply ( const JntArray src,
const double &  factor,
JntArray dest 
)

Function to multiply all the array values with a scalar factor: A*b=C.

This function is aliasing-safe, A can be the same array as C.

Parameters
srcA
factorb
destC

References KDL::JntArray::data.

Referenced by KDL::TreeIkSolverPos_Online::enforceJointVelLimits().

§ Multiply() [5/8]

void KDL::Multiply ( const JntSpaceInertiaMatrix &  src,
const JntArray vec,
JntArray dest 
)

References KDL::JntArray::data.

§ Multiply() [6/8]

void KDL::Multiply ( const JntArrayAcc src,
const double &  factor,
JntArrayAcc dest 
)

§ Multiply() [7/8]

void KDL::Multiply ( const JntArrayAcc src,
const doubleVel factor,
JntArrayAcc dest 
)

§ Multiply() [8/8]

void KDL::Multiply ( const JntArrayAcc src,
const doubleAcc factor,
JntArrayAcc dest 
)

§ MultiplyJacobian()

void KDL::MultiplyJacobian ( const Jacobian jac,
const JntArray src,
Twist dest 
)

Function to multiply a KDL::Jacobian with a KDL::JntArray to get a KDL::Twist, it should not be used to calculate the forward velocity kinematics, the solver classes are built for this purpose.

J*q = t

Parameters
jacJ
srcq
destt
Postcondition
dest==Twist::Zero() if 0==src.rows() (ie src is empty)

References KDL::Jacobian::data, and KDL::JntArray::data.

Referenced by KDL::ChainJntToJacDotSolver::JntToJacDot().

§ operator!=() [1/6]

IMETHOD bool KDL::operator!= ( const Frame a,
const Frame b 
)

§ operator!=() [2/6]

IMETHOD bool KDL::operator!= ( const Vector a,
const Vector b 
)

§ operator!=() [3/6]

IMETHOD bool KDL::operator!= ( const Twist a,
const Twist b 
)

§ operator!=() [4/6]

IMETHOD bool KDL::operator!= ( const Wrench a,
const Wrench b 
)

§ operator!=() [5/6]

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

§ operator!=() [6/6]

IMETHOD bool KDL::operator!= ( const Vector2 a,
const Vector2 b 
)

§ operator*() [1/61]

FrameVel KDL::operator* ( const FrameVel lhs,
const FrameVel rhs 
)

§ operator*() [2/61]

FrameVel KDL::operator* ( const FrameVel lhs,
const Frame rhs 
)

§ operator*() [3/61]

FrameVel KDL::operator* ( const Frame lhs,
const FrameVel rhs 
)

§ operator*() [4/61]

RigidBodyInertia KDL::operator* ( double  a,
const RigidBodyInertia I 
)

Scalar product: I_new = double * I_old.

Scalar product.

References KDL::RigidBodyInertia::h, KDL::RigidBodyInertia::I, KDL::RigidBodyInertia::m, and KDL::RigidBodyInertia::RigidBodyInertia().

§ operator*() [5/61]

RotationalInertia KDL::operator* ( double  a,
const RotationalInertia I 
)

§ operator*() [6/61]

ArticulatedBodyInertia KDL::operator* ( double  a,
const ArticulatedBodyInertia I 
)

Scalar product: I_new = double * I_old.

References KDL::ArticulatedBodyInertia::H, KDL::ArticulatedBodyInertia::I, and KDL::ArticulatedBodyInertia::M.

§ operator*() [7/61]

Wrench KDL::operator* ( const RigidBodyInertia I,
const Twist t 
)

calculate spatial momentum: h = I*v make sure that the twist v and the inertia are expressed in the same reference frame/point

calculate spatial momentum

References KDL::RigidBodyInertia::h, KDL::RigidBodyInertia::I, KDL::RigidBodyInertia::m, KDL::Twist::rot, and KDL::Twist::vel.

§ operator*() [8/61]

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

§ operator*() [9/61]

RigidBodyInertia KDL::operator* ( const Frame T,
const RigidBodyInertia I 
)

Coordinate system transform Ia = T_a_b*Ib with T_a_b the frame from a to b.

coordinate system transform Ia = T_a_b*Ib with T_a_b the frame from a to b

References KDL::RotationalInertia::data, KDL::Vector::data, KDL::Rotation::data, KDL::Vector::dot, KDL::RigidBodyInertia::h, KDL::RigidBodyInertia::I, KDL::Frame::Inverse(), KDL::RigidBodyInertia::m, KDL::Frame::M, KDL::Frame::p, and KDL::RigidBodyInertia::RigidBodyInertia().

§ operator*() [10/61]

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

§ operator*() [11/61]

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

§ operator*() [12/61]

Wrench KDL::operator* ( const ArticulatedBodyInertia I,
const Twist t 
)

calculate spatial momentum: h = I*v make sure that the twist v and the inertia are expressed in the same reference frame/point

References KDL::Vector::data, KDL::Wrench::force, KDL::ArticulatedBodyInertia::H, KDL::ArticulatedBodyInertia::I, KDL::ArticulatedBodyInertia::M, KDL::Twist::rot, KDL::Wrench::torque, and KDL::Twist::vel.

§ operator*() [13/61]

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

§ operator*() [14/61]

RigidBodyInertia KDL::operator* ( const Rotation M,
const RigidBodyInertia I 
)

Reference frame orientation change Ia = R_a_b*Ib with R_a_b the rotation of b expressed in a.

base frame orientation change Ia = R_a_b*Ib with R_a_b the rotation for frame from a to b

References KDL::RotationalInertia::data, KDL::Rotation::data, KDL::RigidBodyInertia::h, KDL::RigidBodyInertia::I, KDL::RigidBodyInertia::m, and KDL::RigidBodyInertia::RigidBodyInertia().

§ operator*() [15/61]

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

§ operator*() [16/61]

ArticulatedBodyInertia KDL::operator* ( const Frame T,
const ArticulatedBodyInertia I 
)

Coordinate system transform Ia = T_a_b*Ib with T_a_b the frame from a to b.

References KDL::Rotation::data, KDL::ArticulatedBodyInertia::H, KDL::ArticulatedBodyInertia::I, KDL::Frame::Inverse(), KDL::ArticulatedBodyInertia::M, KDL::Frame::M, and KDL::Frame::p.

§ operator*() [17/61]

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

§ operator*() [18/61]

Wrench KDL::operator* ( const Stiffness s,
const Twist t 
)
inline

§ operator*() [19/61]

Vector KDL::operator* ( const Vector lhs,
double  rhs 
)

§ operator*() [20/61]

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

§ operator*() [21/61]

ArticulatedBodyInertia KDL::operator* ( const Rotation M,
const ArticulatedBodyInertia I 
)

Reference frame orientation change Ia = R_a_b*Ib with R_a_b the rotation of b expressed in a.

References KDL::Rotation::data, KDL::ArticulatedBodyInertia::H, KDL::ArticulatedBodyInertia::I, and KDL::ArticulatedBodyInertia::M.

§ operator*() [22/61]

Vector KDL::operator* ( double  lhs,
const Vector rhs 
)

§ operator*() [23/61]

RotationVel KDL::operator* ( const RotationVel r1,
const RotationVel r2 
)

§ operator*() [24/61]

RotationVel KDL::operator* ( const Rotation r1,
const RotationVel r2 
)

§ operator*() [25/61]

RotationVel KDL::operator* ( const RotationVel r1,
const Rotation r2 
)

§ operator*() [26/61]

Vector KDL::operator* ( const Vector lhs,
const Vector rhs 
)

§ operator*() [27/61]

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

References KDL::Rotation::data.

§ operator*() [28/61]

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

§ operator*() [29/61]

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

§ operator*() [30/61]

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

§ operator*() [31/61]

Wrench KDL::operator* ( const Wrench lhs,
double  rhs 
)

§ operator*() [32/61]

VectorVel KDL::operator* ( const VectorVel r1,
const VectorVel r2 
)

§ operator*() [33/61]

Wrench KDL::operator* ( double  lhs,
const Wrench rhs 
)

§ operator*() [34/61]

VectorVel KDL::operator* ( const VectorVel r1,
const Vector r2 
)

§ operator*() [35/61]

VectorVel KDL::operator* ( const Vector r1,
const VectorVel r2 
)

§ operator*() [36/61]

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

§ operator*() [37/61]

VectorVel KDL::operator* ( double  r1,
const VectorVel r2 
)

§ operator*() [38/61]

VectorVel KDL::operator* ( const VectorVel r1,
double  r2 
)

§ operator*() [39/61]

VectorVel KDL::operator* ( const doubleVel r1,
const VectorVel r2 
)

§ operator*() [40/61]

VectorVel KDL::operator* ( const VectorVel r2,
const doubleVel r1 
)

§ operator*() [41/61]

VectorVel KDL::operator* ( const Rotation R,
const VectorVel x 
)

§ operator*() [42/61]

Twist KDL::operator* ( const Twist lhs,
double  rhs 
)

§ operator*() [43/61]

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

§ operator*() [44/61]

Twist KDL::operator* ( double  lhs,
const Twist rhs 
)

§ operator*() [45/61]

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

§ operator*() [46/61]

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

§ operator*() [47/61]

Twist KDL::operator* ( const Twist lhs,
const Twist rhs 
)

§ operator*() [48/61]

Wrench KDL::operator* ( const Twist lhs,
const Wrench rhs 
)

§ operator*() [49/61]

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

§ operator*() [50/61]

TwistVel KDL::operator* ( const TwistVel lhs,
double  rhs 
)

§ operator*() [51/61]

TwistVel KDL::operator* ( double  lhs,
const TwistVel rhs 
)

§ operator*() [52/61]

TwistVel KDL::operator* ( const TwistVel lhs,
const doubleVel rhs 
)

§ operator*() [53/61]

TwistVel KDL::operator* ( const doubleVel lhs,
const TwistVel rhs 
)

§ operator*() [54/61]

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

§ operator*() [55/61]

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

§ operator*() [56/61]

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

§ operator*() [57/61]

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

§ operator*() [58/61]

IMETHOD Vector2 KDL::operator* ( const Vector2 lhs,
double  rhs 
)

§ operator*() [59/61]

IMETHOD Vector2 KDL::operator* ( double  lhs,
const Vector2 rhs 
)

§ operator*() [60/61]

IMETHOD Rotation2 KDL::operator* ( const Rotation2 lhs,
const Rotation2 rhs 
)

§ operator*() [61/61]

IMETHOD Frame2 KDL::operator* ( const Frame2 lhs,
const Frame2 rhs 
)

§ operator+() [1/18]

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

§ operator+() [2/18]

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

§ operator+() [3/18]

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

§ operator+() [4/18]

RigidBodyInertia KDL::operator+ ( const RigidBodyInertia Ia,
const RigidBodyInertia Ib 
)

addition I: I_new = I_old1 + I_old2, make sure that I_old1 and I_old2 are expressed in the same reference frame/point, otherwise the result is worth nothing

addition

References KDL::RigidBodyInertia::h, KDL::RigidBodyInertia::I, KDL::RigidBodyInertia::m, and KDL::RigidBodyInertia::RigidBodyInertia().

§ operator+() [5/18]

ArticulatedBodyInertia KDL::operator+ ( const ArticulatedBodyInertia Ia,
const ArticulatedBodyInertia Ib 
)

addition I: I_new = I_old1 + I_old2, make sure that I_old1 and I_old2 are expressed in the same reference frame/point, otherwise the result is worth nothing

References KDL::ArticulatedBodyInertia::H, KDL::ArticulatedBodyInertia::I, and KDL::ArticulatedBodyInertia::M.

§ operator+() [6/18]

RotationalInertia KDL::operator+ ( const RotationalInertia Ia,
const RotationalInertia Ib 
)

§ operator+() [7/18]

IMETHOD Vector KDL::operator+ ( const Vector lhs,
const Vector rhs 
)

§ operator+() [8/18]

ArticulatedBodyInertia KDL::operator+ ( const RigidBodyInertia Ia,
const ArticulatedBodyInertia Ib 
)

§ operator+() [9/18]

Stiffness KDL::operator+ ( const Stiffness s1,
const Stiffness s2 
)
inline

§ operator+() [10/18]

ArticulatedBodyInertia KDL::operator+ ( const ArticulatedBodyInertia Ia,
const RigidBodyInertia Ib 
)

§ operator+() [11/18]

VectorVel KDL::operator+ ( const VectorVel r1,
const VectorVel r2 
)

§ operator+() [12/18]

VectorVel KDL::operator+ ( const VectorVel r1,
const Vector r2 
)

§ operator+() [13/18]

VectorVel KDL::operator+ ( const Vector r1,
const VectorVel r2 
)

§ operator+() [14/18]

Wrench KDL::operator+ ( const Wrench lhs,
const Wrench rhs 
)

§ operator+() [15/18]

Twist KDL::operator+ ( const Twist lhs,
const Twist rhs 
)

§ operator+() [16/18]

TwistVel KDL::operator+ ( const TwistVel lhs,
const TwistVel rhs 
)

§ operator+() [17/18]

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

§ operator+() [18/18]

IMETHOD Vector2 KDL::operator+ ( const Vector2 lhs,
const Vector2 rhs 
)

§ operator-() [1/23]

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

§ operator-() [2/23]

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

§ operator-() [3/23]

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

§ operator-() [4/23]

VectorAcc KDL::operator- ( const VectorAcc r)

§ operator-() [5/23]

ArticulatedBodyInertia KDL::operator- ( const ArticulatedBodyInertia Ia,
const ArticulatedBodyInertia Ib 
)

§ operator-() [6/23]

ArticulatedBodyInertia KDL::operator- ( const RigidBodyInertia Ia,
const ArticulatedBodyInertia Ib 
)

§ operator-() [7/23]

IMETHOD Vector KDL::operator- ( const Vector lhs,
const Vector rhs 
)

§ operator-() [8/23]

ArticulatedBodyInertia KDL::operator- ( const ArticulatedBodyInertia Ia,
const RigidBodyInertia Ib 
)

§ operator-() [9/23]

VectorVel KDL::operator- ( const VectorVel r1,
const VectorVel r2 
)

§ operator-() [10/23]

VectorVel KDL::operator- ( const VectorVel r1,
const Vector r2 
)

§ operator-() [11/23]

VectorVel KDL::operator- ( const Vector r1,
const VectorVel r2 
)

§ operator-() [12/23]

VectorVel KDL::operator- ( const VectorVel r)

§ operator-() [13/23]

Wrench KDL::operator- ( const Wrench lhs,
const Wrench rhs 
)

§ operator-() [14/23]

Wrench KDL::operator- ( const Wrench arg)

§ operator-() [15/23]

Twist KDL::operator- ( const Twist lhs,
const Twist rhs 
)

§ operator-() [16/23]

Twist KDL::operator- ( const Twist arg)

§ operator-() [17/23]

Vector KDL::operator- ( const Vector arg)

§ operator-() [18/23]

TwistVel KDL::operator- ( const TwistVel lhs,
const TwistVel rhs 
)

§ operator-() [19/23]

TwistVel KDL::operator- ( const TwistVel arg)

§ operator-() [20/23]

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

§ operator-() [21/23]

TwistAcc KDL::operator- ( const TwistAcc arg)

§ operator-() [22/23]

IMETHOD Vector2 KDL::operator- ( const Vector2 lhs,
const Vector2 rhs 
)

§ operator-() [23/23]

IMETHOD Vector2 KDL::operator- ( const Vector2 arg)

§ operator/() [1/12]

Vector KDL::operator/ ( const Vector lhs,
double  rhs 
)

§ operator/() [2/12]

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

§ operator/() [3/12]

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

§ operator/() [4/12]

Wrench KDL::operator/ ( const Wrench lhs,
double  rhs 
)

§ operator/() [5/12]

VectorVel KDL::operator/ ( const VectorVel r1,
double  r2 
)

§ operator/() [6/12]

VectorVel KDL::operator/ ( const VectorVel r2,
const doubleVel r1 
)

§ operator/() [7/12]

Twist KDL::operator/ ( const Twist lhs,
double  rhs 
)

§ operator/() [8/12]

TwistVel KDL::operator/ ( const TwistVel lhs,
double  rhs 
)

§ operator/() [9/12]

TwistVel KDL::operator/ ( const TwistVel lhs,
const doubleVel rhs 
)

§ operator/() [10/12]

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

§ operator/() [11/12]

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

§ operator/() [12/12]

IMETHOD Vector2 KDL::operator/ ( const Vector2 lhs,
double  rhs 
)

§ operator<<() [1/24]

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

§ operator<<() [2/24]

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

§ operator<<() [3/24]

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

§ operator<<() [4/24]

std::ostream & KDL::operator<< ( std::ostream &  os,
const Segment segment 
)

§ operator<<() [5/24]

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

§ operator<<() [6/24]

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

§ operator<<() [7/24]

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

§ operator<<() [8/24]

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.

§ operator<<() [9/24]

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

§ operator<<() [10/24]

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

§ operator<<() [11/24]

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

§ operator<<() [12/24]

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

References KDL::Twist::rot, and KDL::Twist::vel.

§ operator<<() [13/24]

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

§ operator<<() [14/24]

std::ostream & KDL::operator<< ( std::ostream &  os,
const Tree tree 
)

§ operator<<() [15/24]

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

§ operator<<() [16/24]

std::ostream & KDL::operator<< ( std::ostream &  os,
SegmentMap::const_iterator  root 
)

§ operator<<() [17/24]

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

§ operator<<() [18/24]

std::ostream & KDL::operator<< ( std::ostream &  os,
const JntArray array 
)

References KDL::JntArray::rows().

§ operator<<() [19/24]

std::ostream & KDL::operator<< ( std::ostream &  os,
const Jacobian jac 
)

§ operator<<() [20/24]

std::ostream & KDL::operator<< ( std::ostream &  os,
const JntSpaceInertiaMatrix &  jntspaceinertiamatrix 
)

§ operator<<() [21/24]

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

References KDL::Frame::M, and KDL::Frame::p.

§ operator<<() [22/24]

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

§ operator<<() [23/24]

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

§ operator<<() [24/24]

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

References KDL::Frame2::M, and KDL::Frame2::p.

§ operator==() [1/8]

bool KDL::operator== ( const JntSpaceInertiaMatrix &  src1,
const JntSpaceInertiaMatrix &  src2 
)

§ operator==() [2/8]

bool KDL::operator== ( const JntArray src1,
const JntArray src2 
)

References KDL::JntArray::Equal.

§ operator==() [3/8]

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

§ operator==() [4/8]

IMETHOD bool KDL::operator== ( const Frame a,
const Frame b 
)

§ operator==() [5/8]

IMETHOD bool KDL::operator== ( const Vector a,
const Vector b 
)

§ operator==() [6/8]

IMETHOD bool KDL::operator== ( const Twist a,
const Twist b 
)

§ operator==() [7/8]

IMETHOD bool KDL::operator== ( const Wrench a,
const Wrench b 
)

§ operator==() [8/8]

IMETHOD bool KDL::operator== ( const Vector2 a,
const Vector2 b 
)

§ operator>>() [1/15]

std::istream & KDL::operator>> ( std::istream &  is,
Joint joint 
)

§ operator>>() [2/15]

std::istream & KDL::operator>> ( std::istream &  is,
Segment segment 
)

§ operator>>() [3/15]

std::istream & KDL::operator>> ( std::istream &  is,
Chain chain 
)

§ operator>>() [4/15]

std::istream & KDL::operator>> ( std::istream &  is,
Tree tree 
)

§ operator>>() [5/15]

std::istream & KDL::operator>> ( std::istream &  is,
JntArray array 
)

§ operator>>() [6/15]

std::istream & KDL::operator>> ( std::istream &  is,
Jacobian jac 
)

§ operator>>() [7/15]

std::istream & KDL::operator>> ( std::istream &  is,
JntSpaceInertiaMatrix &  jntspaceinertiamatrix 
)

§ operator>>() [8/15]

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

References KDL::Vector::Zero().

§ operator>>() [9/15]

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

References KDL::Twist::rot, and KDL::Twist::vel.

§ operator>>() [10/15]

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

§ operator>>() [11/15]

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

§ operator>>() [12/15]

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

§ operator>>() [13/15]

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

§ operator>>() [14/15]

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

References KDL::Rotation2::Rot().

§ operator>>() [15/15]

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

References KDL::Frame2::M, and KDL::Frame2::p.

§ posrandom() [1/11]

IMETHOD void KDL::posrandom ( doubleVel F)

§ posrandom() [2/11]

void KDL::posrandom ( Stiffness F)
inline

References posrandom().

§ posrandom() [3/11]

IMETHOD void KDL::posrandom ( VectorVel a)

§ posrandom() [4/11]

IMETHOD void KDL::posrandom ( TwistVel a)

§ posrandom() [5/11]

IMETHOD void KDL::posrandom ( RotationVel R)

§ posrandom() [6/11]

IMETHOD void KDL::posrandom ( FrameVel F)

§ posrandom() [7/11]

IMETHOD void KDL::posrandom ( Vector a)

Referenced by posrandom(), and random().

§ posrandom() [8/11]

IMETHOD void KDL::posrandom ( Twist a)

§ posrandom() [9/11]

IMETHOD void KDL::posrandom ( Wrench a)

§ posrandom() [10/11]

IMETHOD void KDL::posrandom ( Rotation R)

§ posrandom() [11/11]

IMETHOD void KDL::posrandom ( Frame F)

§ random() [1/11]

IMETHOD void KDL::random ( doubleVel F)

§ random() [2/11]

void KDL::random ( Stiffness F)
inline

References posrandom().

§ random() [3/11]

IMETHOD void KDL::random ( VectorVel a)

References KDL::VectorVel::p, and random().

§ random() [4/11]

IMETHOD void KDL::random ( TwistVel a)

§ random() [5/11]

IMETHOD void KDL::random ( RotationVel R)

§ random() [6/11]

IMETHOD void KDL::random ( FrameVel F)

§ random() [7/11]

IMETHOD void KDL::random ( Vector a)

addDelta operator for displacement rotational velocity.

The Vector arguments here represent a displacement rotational velocity. i.e. a rotation around a fixed axis for a certain angle. For this representation you cannot use diff() but have to use diff_displ().

Parameters
a: displacement rotational velocity
da: rotational velocity
Returns
displacement rotational velocity
Warning
do not confuse displacement rotational velocities and velocities
do not confuse displacement twist and twist.

IMETHOD Vector addDelta_displ(const Vector& a,const Vector&da,double dt) { return getRot(addDelta(Rot(a),da,dt)); } addDelta operator for displacement twist.

The Vector arguments here represent a displacement rotational velocity. i.e. a rotation around a fixed axis for a certain angle. For this representation you cannot use diff() but have to use diff_displ().

Parameters
a: displacement twist
da: twist
Returns
displacement twist
Warning
do not confuse displacement rotational velocities and velocities
do not confuse displacement twist and twist.

IMETHOD Twist addDelta_displ(const Twist& a,const Twist&da,double dt) { return Twist(addDelta(a.vel,da.vel,dt),addDelta_displ(a.rot,da.rot,dt)); }

Referenced by random().

§ random() [8/11]

IMETHOD void KDL::random ( Twist a)

§ random() [9/11]

IMETHOD void KDL::random ( Wrench a)

§ random() [10/11]

IMETHOD void KDL::random ( Rotation R)

§ random() [11/11]

IMETHOD void KDL::random ( Frame F)

§ Rot()

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.

This routine returns the rotation matrix R_a_b

§ SetToZero() [1/11]

void KDL::SetToZero ( Jacobian jac)

References KDL::Jacobian::data.

§ SetToZero() [2/11]

void KDL::SetToZero ( JntArrayVel array)

§ SetToZero() [3/11]

void KDL::SetToZero ( JntSpaceInertiaMatrix &  mat)

§ SetToZero() [4/11]

void KDL::SetToZero ( JntArray array)

Function to set all the values of the array to 0.

Parameters
array

References KDL::JntArray::data.

§ SetToZero() [5/11]

void KDL::SetToZero ( JntArrayAcc array)

§ SetToZero() [6/11]

void KDL::SetToZero ( VectorVel v)

§ SetToZero() [7/11]

void KDL::SetToZero ( TwistVel v)

§ SetToZero() [8/11]

IMETHOD void KDL::SetToZero ( Vector v)

§ SetToZero() [9/11]

IMETHOD void KDL::SetToZero ( Twist v)

§ SetToZero() [10/11]

IMETHOD void KDL::SetToZero ( Wrench v)

§ SetToZero() [11/11]

IMETHOD void KDL::SetToZero ( Vector2 v)

§ Subtract() [1/7]

void KDL::Subtract ( const JntArrayVel src1,
const JntArrayVel src2,
JntArrayVel dest 
)

§ Subtract() [2/7]

void KDL::Subtract ( const JntArrayVel src1,
const JntArray src2,
JntArrayVel dest 
)

§ Subtract() [3/7]

void KDL::Subtract ( const JntArrayAcc src1,
const JntArrayAcc src2,
JntArrayAcc dest 
)

§ Subtract() [4/7]

void KDL::Subtract ( const JntSpaceInertiaMatrix &  src1,
const JntSpaceInertiaMatrix &  src2,
JntSpaceInertiaMatrix &  dest 
)

§ Subtract() [5/7]

void KDL::Subtract ( const JntArray src1,
const JntArray src2,
JntArray dest 
)

Function to subtract two joint arrays, all the arguments must have the same size: A - B = C.

This function is aliasing-safe, A or B can be the same array as C.

Parameters
src1A
src2B
destC

References KDL::JntArray::data.

§ Subtract() [6/7]

void KDL::Subtract ( const JntArrayAcc src1,
const JntArrayVel src2,
JntArrayAcc dest 
)

§ Subtract() [7/7]

void KDL::Subtract ( const JntArrayAcc src1,
const JntArray src2,
JntArrayAcc dest 
)

§ svd_eigen_Macie()

int KDL::svd_eigen_Macie ( const MatrixXd &  A,
MatrixXd &  U,
VectorXd &  S,
MatrixXd &  V,
MatrixXd &  B,
VectorXd &  tempi,
double  threshold,
bool  toggle 
)

svd_eigen_Macie provides Maciejewski implementation for SVD.

computes the singular value decomposition of a matrix A, such that A=U*Sm*V

(Maciejewski and Klein,1989) and (Braun, Ulrey, Maciejewski and Siegel,2002)

Parameters
A[INPUT] is an \(m \times n\)-matrix, where \( m \geq n \).
S[OUTPUT] is an \(n\)-vector, representing the diagonal elements of the diagonal matrix Sm.
U[INPUT/OUTPUT] is an \(m \times m\) orthonormal matrix.
V[INPUT/OUTPUT] is an \(n \times n\) orthonormal matrix.
B[TEMPORARY] is an \(m \times n\) matrix used for temporary storage.
tempi[TEMPORARY] is an \(m\) vector used for temporary storage.
threshold[INPUT] Threshold to determine orthogonality.
toggle[INPUT] toggle this boolean variable on each call of this routine.
Returns
number of sweeps.

Referenced by KDL::ChainIkSolverVel_pinv_givens::CartToJnt().

§ Twist_to_Eigen()

template<typename Derived >
void KDL::Twist_to_Eigen ( const KDL::Twist t,
Eigen::MatrixBase< Derived > &  e 
)
inline

Variable Documentation

§ mhi

const bool KDL::mhi =true
static