KDL 1.5.1
Loading...
Searching...
No Matches
KDL Namespace Reference

Classes

class  ArticulatedBodyInertia
 6D Inertia of a articulated body More...
 
class  Chain
 
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  ChainExternalWrenchEstimator
 First-order momentum observer for the estimation of external wrenches applied on the robot's end-effector. More...
 
class  ChainFdSolver
 This abstract class encapsulates the inverse dynamics solver for a KDL::Chain. More...
 
class  ChainFdSolver_RNE
 Recursive newton euler forward dynamics solver. 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  ChainHdSolver_Vereshchagin
 Abstract: Acceleration constrained hybrid dynamics calculations for a chain, based on Vereshchagin 1989. 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
 
class  ChainIkSolverAcc
 
class  ChainIkSolverPos
 
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
 
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
 
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
 
class  JntArrayAcc
 
class  JntArrayVel
 
class  Joint
 
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
 
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
 
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  TreeIdSolver
 This abstract class encapsulates the inverse dynamics solver for a KDL::Tree. More...
 
class  TreeIdSolver_RNE
 Recursive newton euler inverse dynamics solver for kinematic trees. 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, WrenchWrenchMap
 
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.
 
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
 
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
 
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.
 
ArticulatedBodyInertia 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.
 
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=epsilon)
 
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.
 
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.
 
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.
 
IMETHOD Twist diff (const Twist &a, const Twist &b, double dt=1)
 determines the difference between two twists i.e.
 
IMETHOD Wrench diff (const Wrench &W_a_p1, const Wrench &W_a_p2, double dt=1)
 determines the difference between two wrenches i.e.
 
IMETHOD Vector addDelta (const Vector &p_w_a, const Vector &p_w_da, double dt=1)
 adds vector da to vector a.
 
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.
 
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).
 
IMETHOD Twist addDelta (const Twist &a, const Twist &da, double dt=1)
 adds the twist da to the twist a.
 
IMETHOD Wrench addDelta (const Wrench &a, const Wrench &da, double dt=1)
 adds the wrench da to the wrench w.
 
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.
 
IMETHOD void random (Vector &a)
 addDelta operator for displacement rotational velocity.
 
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.
 
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)
 
bool operator== (const FrameVel &r1, const FrameVel &r2)
 
bool operator!= (const FrameVel &r1, const FrameVel &r2)
 
bool operator== (const Frame &r1, const FrameVel &r2)
 
bool operator!= (const Frame &r1, const FrameVel &r2)
 
bool operator== (const FrameVel &r1, const Frame &r2)
 
bool operator!= (const FrameVel &r1, const Frame &r2)
 
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)
 
bool operator== (const VectorVel &r1, const VectorVel &r2)
 
bool operator!= (const VectorVel &r1, const VectorVel &r2)
 
bool operator== (const Vector &r1, const VectorVel &r2)
 
bool operator!= (const Vector &r1, const VectorVel &r2)
 
bool operator== (const VectorVel &r1, const Vector &r2)
 
bool operator!= (const VectorVel &r1, const Vector &r2)
 
bool operator== (const RotationVel &r1, const RotationVel &r2)
 
bool operator!= (const RotationVel &r1, const RotationVel &r2)
 
bool operator== (const Rotation &r1, const RotationVel &r2)
 
bool operator!= (const Rotation &r1, const RotationVel &r2)
 
bool operator== (const RotationVel &r1, const Rotation &r2)
 
bool operator!= (const RotationVel &r1, const Rotation &r2)
 
bool operator== (const TwistVel &a, const TwistVel &b)
 
bool operator!= (const TwistVel &a, const TwistVel &b)
 
bool operator== (const Twist &a, const TwistVel &b)
 
bool operator!= (const Twist &r1, const TwistVel &r2)
 
bool operator== (const TwistVel &r1, const Twist &r2)
 
bool operator!= (const TwistVel &r1, const Twist &r2)
 
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=epsilon)
 
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.
 
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.
 
void Multiply (const JntArray &src, const double &factor, JntArray &dest)
 Function to multiply all the array values with a scalar factor: A*b=C.
 
void Divide (const JntArray &src, const double &factor, JntArray &dest)
 Function to divide all the array values with a scalar factor: A/b=C.
 
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.
 
void SetToZero (JntArray &array)
 Function to set all the values of the array to 0.
 
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.
 
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=epsilon)
 
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=epsilon)
 
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)
 
std::string tree2str (const SegmentMap::const_iterator it, const std::string &separator, const std::string &preamble, unsigned int level)
 
std::string tree2str (const Tree &tree, const std::string &separator, const std::string &preamble)
 
RigidBodyInertia operator* (double a, const RigidBodyInertia &I)
 Scalar product: I_new = double * I_old.
 
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
 
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
 
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.
 
RigidBodyInertia 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.
 
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 Eigen::MatrixXd &A, Eigen::MatrixXd &U, Eigen::VectorXd &S, Eigen::MatrixXd &V, Eigen::MatrixXd &B, Eigen::VectorXd &tempi, double threshold, bool toggle)
 svd_eigen_Macie provides Maciejewski implementation for SVD.
 

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

◆ WrenchMap

typedef std::map<std::string,Wrench> KDL::WrenchMap

Function Documentation

◆ Add() [1/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

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

◆ Add() [2/7]

void KDL::Add ( const JntArrayAcc & src1,
const JntArray & src2,
JntArrayAcc & 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 JntArrayVel & src1,
const JntArray & src2,
JntArrayVel & dest )

◆ Add() [6/7]

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

◆ Add() [7/7]

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

References Add().

◆ addDelta() [1/9]

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

◆ addDelta() [2/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() [3/9]

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

◆ addDelta() [4/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() [5/9]

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

◆ addDelta() [6/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() [7/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 addDelta(), and addDelta().

◆ addDelta() [8/9]

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

◆ 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 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() [3/9]

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

◆ diff() [4/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() [5/9]

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

◆ diff() [6/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() [7/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::ChainIkSolverPos_LMA::CartToJnt(), KDL::ChainIkSolverPos_NR::CartToJnt(), KDL::ChainIkSolverPos_NR_JL::CartToJnt(), KDL::TreeIkSolverPos_NR_JL::CartToJnt(), KDL::TreeIkSolverPos_Online::CartToJnt(), diff(), diff(), KDL::VelocityProfile_Rectangular::SetProfile(), and KDL::VelocityProfile_Rectangular::SetProfileDuration().

◆ diff() [8/9]

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

◆ 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 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

Referenced by Divide().

◆ Divide() [2/7]

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

◆ Divide() [3/7]

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

◆ Divide() [4/7]

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

◆ Divide() [5/7]

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

◆ Divide() [6/7]

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

◆ Divide() [7/7]

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

References Divide().

◆ dot() [1/9]

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

◆ dot() [2/9]

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

◆ dot() [3/9]

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

◆ dot() [4/9]

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

◆ dot() [5/9]

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

◆ dot() [6/9]

◆ dot() [7/9]

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

◆ dot() [8/9]

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

◆ dot() [9/9]

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

◆ Equal() [1/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() [2/37]

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

◆ Equal() [3/37]

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

◆ Equal() [4/37]

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

◆ Equal() [5/37]

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

◆ Equal() [6/37]

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

◆ Equal() [7/37]

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

◆ Equal() [8/37]

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

◆ Equal() [9/37]

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

◆ Equal() [10/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())

◆ Equal() [11/37]

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

◆ Equal() [12/37]

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

◆ Equal() [13/37]

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

◆ Equal() [14/37]

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

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

◆ Equal() [15/37]

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

◆ Equal() [16/37]

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

◆ Equal() [17/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() [18/37]

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

◆ Equal() [19/37]

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

◆ Equal() [20/37]

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

◆ Equal() [21/37]

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

◆ Equal() [22/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() [23/37]

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

◆ Equal() [24/37]

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

◆ Equal() [25/37]

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

◆ Equal() [26/37]

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

◆ Equal() [27/37]

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

◆ Equal() [28/37]

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

◆ 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]

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

◆ Equal() [31/37]

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

◆ Equal() [32/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() [33/37]

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

◆ Equal() [34/37]

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

◆ Equal() [35/37]

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

◆ Equal() [36/37]

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

◆ Equal() [37/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

◆ generatePowers()

◆ Multiply() [1/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

Referenced by KDL::TreeIkSolverPos_Online::enforceJointVelLimits(), Multiply(), and Multiply().

◆ Multiply() [2/8]

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

◆ Multiply() [3/8]

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

◆ Multiply() [4/8]

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

◆ Multiply() [5/8]

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

◆ Multiply() [6/8]

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

◆ Multiply() [7/8]

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

References Multiply().

◆ Multiply() [8/8]

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

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

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

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

◆ operator!=() [1/18]

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

◆ operator!=() [2/18]

bool KDL::operator!= ( const Frame & r1,
const FrameVel & r2 )

◆ operator!=() [3/18]

bool KDL::operator!= ( const FrameVel & r1,
const Frame & r2 )

◆ operator!=() [4/18]

bool KDL::operator!= ( const FrameVel & r1,
const FrameVel & r2 )

◆ operator!=() [5/18]

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

◆ operator!=() [6/18]

bool KDL::operator!= ( const Rotation & r1,
const RotationVel & r2 )

◆ operator!=() [7/18]

bool KDL::operator!= ( const RotationVel & r1,
const Rotation & r2 )

◆ operator!=() [8/18]

bool KDL::operator!= ( const RotationVel & r1,
const RotationVel & r2 )

◆ operator!=() [9/18]

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

◆ operator!=() [10/18]

bool KDL::operator!= ( const Twist & r1,
const TwistVel & r2 )

◆ operator!=() [11/18]

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

◆ operator!=() [12/18]

bool KDL::operator!= ( const TwistVel & r1,
const Twist & r2 )

◆ operator!=() [13/18]

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

◆ operator!=() [14/18]

bool KDL::operator!= ( const Vector & r1,
const VectorVel & r2 )

◆ operator!=() [15/18]

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

◆ operator!=() [16/18]

bool KDL::operator!= ( const VectorVel & r1,
const Vector & r2 )

◆ operator!=() [17/18]

bool KDL::operator!= ( const VectorVel & r1,
const VectorVel & r2 )

◆ operator!=() [18/18]

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

◆ operator*() [1/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

◆ operator*() [2/61]

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

◆ operator*() [3/61]

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

◆ operator*() [4/61]

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

◆ operator*() [5/61]

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

◆ operator*() [6/61]

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

◆ operator*() [7/61]

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

◆ operator*() [8/61]

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

◆ operator*() [9/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.

◆ operator*() [10/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

◆ operator*() [11/61]

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

◆ operator*() [12/61]

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

◆ operator*() [13/61]

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

◆ operator*() [14/61]

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

◆ operator*() [15/61]

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

◆ operator*() [16/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

◆ operator*() [17/61]

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

◆ operator*() [18/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.

◆ operator*() [19/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

◆ operator*() [20/61]

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

◆ operator*() [21/61]

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

◆ operator*() [22/61]

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

◆ operator*() [23/61]

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

◆ operator*() [24/61]

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

◆ operator*() [25/61]

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

◆ operator*() [26/61]

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

◆ operator*() [27/61]

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

◆ operator*() [28/61]

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

◆ operator*() [29/61]

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

◆ operator*() [30/61]

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

◆ operator*() [31/61]

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

◆ operator*() [32/61]

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

◆ operator*() [33/61]

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

◆ operator*() [34/61]

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

◆ operator*() [35/61]

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

◆ operator*() [36/61]

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

◆ operator*() [37/61]

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

◆ operator*() [38/61]

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

◆ operator*() [39/61]

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

◆ operator*() [40/61]

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

◆ operator*() [41/61]

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

◆ operator*() [42/61]

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

◆ operator*() [43/61]

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

◆ operator*() [44/61]

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

◆ operator*() [45/61]

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

◆ operator*() [46/61]

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

◆ operator*() [47/61]

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

◆ operator*() [48/61]

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

◆ operator*() [49/61]

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

◆ operator*() [50/61]

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

◆ operator*() [51/61]

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

Scalar product: I_new = double * I_old.

◆ operator*() [52/61]

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

Scalar product: I_new = double * I_old.

Scalar product.

◆ operator*() [53/61]

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

◆ operator*() [54/61]

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

◆ operator*() [55/61]

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

◆ operator*() [56/61]

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

◆ operator*() [57/61]

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

◆ operator*() [58/61]

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

◆ operator*() [59/61]

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

◆ operator*() [60/61]

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

◆ operator*() [61/61]

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

◆ operator+() [1/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

◆ operator+() [2/18]

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

◆ operator+() [3/18]

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

◆ 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

◆ operator+() [5/18]

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

◆ operator+() [6/18]

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

◆ operator+() [7/18]

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

◆ operator+() [8/18]

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

◆ operator+() [9/18]

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

◆ operator+() [10/18]

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

◆ operator+() [11/18]

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

◆ operator+() [12/18]

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

◆ operator+() [13/18]

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

◆ operator+() [14/18]

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

◆ operator+() [15/18]

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

◆ operator+() [16/18]

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

◆ operator+() [17/18]

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

◆ operator+() [18/18]

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

◆ operator-() [1/23]

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

◆ operator-() [2/23]

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

◆ operator-() [3/23]

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

◆ operator-() [4/23]

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

◆ operator-() [5/23]

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

◆ operator-() [6/23]

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

◆ operator-() [7/23]

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

◆ operator-() [8/23]

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

◆ operator-() [9/23]

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

◆ operator-() [10/23]

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

◆ operator-() [11/23]

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

◆ operator-() [12/23]

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

◆ operator-() [13/23]

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

◆ operator-() [14/23]

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

◆ operator-() [15/23]

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

◆ operator-() [16/23]

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

◆ operator-() [17/23]

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

◆ operator-() [18/23]

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

◆ operator-() [19/23]

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

◆ operator-() [20/23]

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

◆ operator-() [21/23]

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

◆ operator-() [22/23]

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

◆ operator-() [23/23]

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

◆ operator/() [1/12]

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

◆ operator/() [2/12]

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

◆ operator/() [3/12]

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

◆ operator/() [4/12]

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

◆ operator/() [5/12]

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

◆ operator/() [6/12]

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

◆ operator/() [7/12]

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

◆ operator/() [8/12]

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

◆ operator/() [9/12]

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

◆ operator/() [10/12]

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

◆ operator/() [11/12]

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

◆ operator/() [12/12]

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

◆ operator<<() [1/24]

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

◆ operator<<() [2/24]

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

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

◆ operator<<() [3/24]

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

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

◆ operator<<() [4/24]

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

◆ operator<<() [5/24]

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

◆ operator<<() [6/24]

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

◆ operator<<() [7/24]

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

References KDL::JntArray::rows().

◆ operator<<() [8/24]

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

◆ operator<<() [9/24]

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

◆ operator<<() [10/24]

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

◆ operator<<() [11/24]

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

◆ operator<<() [12/24]

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

◆ operator<<() [13/24]

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

◆ operator<<() [14/24]

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

◆ operator<<() [15/24]

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

◆ operator<<() [16/24]

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

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

◆ operator<<() [17/24]

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

◆ operator<<() [18/24]

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

◆ operator<<() [19/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<<() [20/24]

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

◆ operator<<() [21/24]

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

◆ operator<<() [22/24]

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

◆ operator<<() [23/24]

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

◆ operator<<() [24/24]

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

◆ operator==() [1/20]

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

◆ operator==() [2/20]

bool KDL::operator== ( const Frame & r1,
const FrameVel & r2 )

◆ operator==() [3/20]

bool KDL::operator== ( const FrameVel & r1,
const Frame & r2 )

◆ operator==() [4/20]

bool KDL::operator== ( const FrameVel & r1,
const FrameVel & r2 )

◆ operator==() [5/20]

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

◆ operator==() [6/20]

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

References Equal().

◆ operator==() [7/20]

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

◆ operator==() [8/20]

bool KDL::operator== ( const Rotation & r1,
const RotationVel & r2 )

◆ operator==() [9/20]

bool KDL::operator== ( const RotationVel & r1,
const Rotation & r2 )

◆ operator==() [10/20]

bool KDL::operator== ( const RotationVel & r1,
const RotationVel & r2 )

◆ operator==() [11/20]

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

◆ operator==() [12/20]

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

◆ operator==() [13/20]

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

◆ operator==() [14/20]

bool KDL::operator== ( const TwistVel & r1,
const Twist & r2 )

◆ operator==() [15/20]

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

◆ operator==() [16/20]

bool KDL::operator== ( const Vector & r1,
const VectorVel & r2 )

◆ operator==() [17/20]

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

◆ operator==() [18/20]

bool KDL::operator== ( const VectorVel & r1,
const Vector & r2 )

◆ operator==() [19/20]

bool KDL::operator== ( const VectorVel & r1,
const VectorVel & r2 )

◆ operator==() [20/20]

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

◆ operator>>() [1/15]

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

◆ operator>>() [2/15]

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

◆ operator>>() [3/15]

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

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

◆ operator>>() [4/15]

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

◆ operator>>() [5/15]

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

◆ operator>>() [6/15]

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

◆ operator>>() [7/15]

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

◆ operator>>() [8/15]

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

◆ operator>>() [9/15]

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

References KDL::Rotation2::Rot().

◆ operator>>() [10/15]

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

◆ operator>>() [11/15]

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

◆ operator>>() [12/15]

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

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

◆ operator>>() [13/15]

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

References KDL::Vector::Zero().

◆ operator>>() [14/15]

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

◆ operator>>() [15/15]

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

◆ posrandom() [1/11]

IMETHOD void KDL::posrandom ( doubleVel & F)

◆ posrandom() [2/11]

IMETHOD void KDL::posrandom ( Frame & F)

◆ posrandom() [3/11]

IMETHOD void KDL::posrandom ( FrameVel & F)

◆ posrandom() [4/11]

IMETHOD void KDL::posrandom ( Rotation & R)

◆ posrandom() [5/11]

IMETHOD void KDL::posrandom ( RotationVel & R)

◆ posrandom() [6/11]

void KDL::posrandom ( Stiffness & F)
inline

References posrandom().

◆ posrandom() [7/11]

IMETHOD void KDL::posrandom ( Twist & a)

◆ posrandom() [8/11]

IMETHOD void KDL::posrandom ( TwistVel & a)

◆ posrandom() [9/11]

IMETHOD void KDL::posrandom ( Vector & a)

Referenced by posrandom(), posrandom(), and random().

◆ posrandom() [10/11]

IMETHOD void KDL::posrandom ( VectorVel & a)

◆ posrandom() [11/11]

IMETHOD void KDL::posrandom ( Wrench & a)

◆ random() [1/11]

IMETHOD void KDL::random ( doubleVel & F)

◆ random() [2/11]

IMETHOD void KDL::random ( Frame & F)

◆ random() [3/11]

IMETHOD void KDL::random ( FrameVel & F)

◆ random() [4/11]

IMETHOD void KDL::random ( Rotation & R)

◆ random() [5/11]

IMETHOD void KDL::random ( RotationVel & R)

References KDL::RotationVel::R, and random().

◆ random() [6/11]

void KDL::random ( Stiffness & F)
inline

References posrandom().

◆ random() [7/11]

IMETHOD void KDL::random ( Twist & a)

◆ random() [8/11]

IMETHOD void KDL::random ( TwistVel & a)

◆ random() [9/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(), and random().

◆ random() [10/11]

IMETHOD void KDL::random ( VectorVel & a)

◆ random() [11/11]

IMETHOD void KDL::random ( Wrench & a)

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

◆ SetToZero() [2/11]

void KDL::SetToZero ( JntArray & array)

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

Parameters
array

◆ SetToZero() [3/11]

void KDL::SetToZero ( JntArrayAcc & array)

◆ SetToZero() [4/11]

void KDL::SetToZero ( JntArrayVel & array)

◆ SetToZero() [5/11]

void KDL::SetToZero ( JntSpaceInertiaMatrix & mat)

◆ SetToZero() [6/11]

IMETHOD void KDL::SetToZero ( Twist & v)

◆ SetToZero() [7/11]

void KDL::SetToZero ( TwistVel & v)

◆ SetToZero() [8/11]

◆ SetToZero() [9/11]

IMETHOD void KDL::SetToZero ( Vector2 & v)

◆ SetToZero() [10/11]

void KDL::SetToZero ( VectorVel & v)

◆ SetToZero() [11/11]

IMETHOD void KDL::SetToZero ( Wrench & v)

◆ Subtract() [1/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

Referenced by Subtract().

◆ Subtract() [2/7]

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

◆ Subtract() [3/7]

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

◆ Subtract() [4/7]

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

◆ Subtract() [5/7]

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

◆ Subtract() [6/7]

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

◆ Subtract() [7/7]

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

References Subtract().

◆ svd_eigen_Macie()

int KDL::svd_eigen_Macie ( const Eigen::MatrixXd & A,
Eigen::MatrixXd & U,
Eigen::VectorXd & S,
Eigen::MatrixXd & V,
Eigen::MatrixXd & B,
Eigen::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().

◆ tree2str() [1/2]

std::string KDL::tree2str ( const SegmentMap::const_iterator it,
const std::string & separator,
const std::string & preamble,
unsigned int level )

◆ tree2str() [2/2]

std::string KDL::tree2str ( const Tree & tree,
const std::string & separator,
const std::string & preamble )

◆ 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