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)
 
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.
 
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)
 
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(), addDelta(), addDelta(), addDelta(), 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(), diff(), diff(), 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().

◆ Equal() [1/37]

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]

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

◆ Equal() [3/37]

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

◆ Equal() [4/37]

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

◆ Equal() [5/37]

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

◆ Equal() [6/37]

◆ Equal() [7/37]

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

◆ Equal() [8/37]

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

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

◆ Equal() [16/37]

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

◆ Equal() [17/37]

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]

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

◆ Equal() [19/37]

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

◆ Equal() [20/37]

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

◆ Equal() [21/37]

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

◆ Equal() [22/37]

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]

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

◆ Equal() [24/37]

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

◆ Equal() [25/37]

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

◆ Equal() [26/37]

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

◆ Equal() [27/37]

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

◆ Equal() [28/37]

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

◆ Equal() [29/37]

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 Vector & r1,
const VectorAcc & r2,
double eps = epsilon )

◆ Equal() [31/37]

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

◆ Equal() [32/37]

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]

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

◆ Equal() [34/37]

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

◆ Equal() [35/37]

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

◆ Equal() [36/37]

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

◆ Equal() [37/37]

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/11]

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/11]

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*() [3/11]

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*() [4/11]

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*() [5/11]

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

◆ operator*() [6/11]

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*() [7/11]

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*() [8/11]

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

◆ operator*() [9/11]

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

Scalar product: I_new = double * I_old.

◆ operator*() [10/11]

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

Scalar product: I_new = double * I_old.

Scalar product.

◆ operator*() [11/11]

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

◆ operator+() [1/6]

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/6]

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

◆ operator+() [3/6]

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

◆ operator+() [4/6]

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/6]

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

◆ operator+() [6/6]

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

◆ operator-() [1/3]

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

◆ operator-() [2/3]

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

◆ operator-() [3/3]

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

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

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

◆ operator==() [2/3]

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

References Equal().

◆ operator==() [3/3]

bool KDL::operator== ( const Rotation & a,
const Rotation & 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/6]

◆ posrandom() [2/6]

IMETHOD void KDL::posrandom ( FrameVel & F)

◆ posrandom() [3/6]

IMETHOD void KDL::posrandom ( RotationVel & R)

◆ posrandom() [4/6]

void KDL::posrandom ( Stiffness & F)
inline

References posrandom().

◆ posrandom() [5/6]

IMETHOD void KDL::posrandom ( TwistVel & a)

◆ posrandom() [6/6]

IMETHOD void KDL::posrandom ( VectorVel & a)

◆ random() [1/6]

IMETHOD void KDL::random ( doubleVel & F)

◆ random() [2/6]

IMETHOD void KDL::random ( FrameVel & F)

◆ random() [3/6]

IMETHOD void KDL::random ( RotationVel & R)

◆ random() [4/6]

void KDL::random ( Stiffness & F)
inline

References posrandom().

◆ random() [5/6]

IMETHOD void KDL::random ( TwistVel & a)

◆ random() [6/6]

IMETHOD void KDL::random ( VectorVel & a)

◆ SetToZero() [1/5]

◆ SetToZero() [2/5]

void KDL::SetToZero ( JntArray & array)

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

Parameters
array

◆ SetToZero() [3/5]

void KDL::SetToZero ( JntArrayAcc & array)

◆ SetToZero() [4/5]

void KDL::SetToZero ( JntArrayVel & array)

◆ SetToZero() [5/5]

void KDL::SetToZero ( JntSpaceInertiaMatrix & mat)

◆ 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