KDL 1.5.1
|
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< Wrench > | Wrenches |
typedef Rall2d< double, double, double > | doubleAcc |
typedef Rall1d< double > | doubleVel |
typedef std::map< std::string, TreeElement > | SegmentMap |
typedef TreeElement | TreeElementType |
typedef std::map< std::string, Wrench > | WrenchMap |
typedef std::map< std::string, Twist > | Twists |
typedef std::map< std::string, Jacobian > | Jacobians |
typedef std::map< std::string, Frame > | Frames |
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 Rall2d<double,double,double> KDL::doubleAcc |
typedef Rall1d<double> KDL::doubleVel |
typedef std::map<std::string, Frame> KDL::Frames |
typedef std::map<std::string, Jacobian> KDL::Jacobians |
typedef std::map<std::string,TreeElement> KDL::SegmentMap |
typedef TreeElement KDL::TreeElementType |
typedef std::map<std::string, Twist> KDL::Twists |
typedef std::vector< Wrench > KDL::Wrenches |
typedef std::map<std::string,Wrench> KDL::WrenchMap |
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.
src1 | A |
src2 | B |
dest | C |
Referenced by Add(), KDL::ChainIkSolverPos_NR::CartToJnt(), KDL::ChainIkSolverPos_NR_JL::CartToJnt(), KDL::TreeIkSolverPos_NR_JL::CartToJnt(), and KDL::TreeIkSolverPos_Online::CartToJnt().
void KDL::Add | ( | const JntArrayAcc & | src1, |
const JntArray & | src2, | ||
JntArrayAcc & | dest ) |
void KDL::Add | ( | const JntArrayAcc & | src1, |
const JntArrayAcc & | src2, | ||
JntArrayAcc & | dest ) |
void KDL::Add | ( | const JntArrayAcc & | src1, |
const JntArrayVel & | src2, | ||
JntArrayAcc & | dest ) |
void KDL::Add | ( | const JntArrayVel & | src1, |
const JntArray & | src2, | ||
JntArrayVel & | dest ) |
void KDL::Add | ( | const JntArrayVel & | src1, |
const JntArrayVel & | src2, | ||
JntArrayVel & | dest ) |
void KDL::Add | ( | const JntSpaceInertiaMatrix & | src1, |
const JntSpaceInertiaMatrix & | src2, | ||
JntSpaceInertiaMatrix & | dest ) |
References Add().
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.
R_w_a | Rotation matrix of frame a expressed to some frame w. |
da_w | axis and angle of the rotation (da_w.rot), together with a displacement vector for the origin (da_w.vel), expressed to some frame w. |
References addDelta(), KDL::FrameVel::M, KDL::FrameVel::p, KDL::TwistVel::rot, and KDL::TwistVel::vel.
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.
R_w_a | Rotation matrix of frame a expressed to some frame w. |
da_w | axis and angle of the rotation expressed to some frame w. |
IMETHOD RotationVel KDL::addDelta | ( | const RotationVel & | a, |
const VectorVel & | da, | ||
double | dt = 1.0 ) |
adds the twist da to the twist a.
see also the corresponding diff() routine.
a | a twist wrt some frame |
da | a twist difference wrt some frame |
adds vector da to vector a.
see also the corresponding diff() routine.
p_w_a | vector a expressed to some frame w. |
p_w_da | vector da expressed to some frame w. |
Referenced by addDelta(), and addDelta().
References addDelta(), KDL::VectorVel::p, and KDL::VectorVel::v.
Referenced by KDL::TreeJntToJacSolver::JntToJac().
Referenced by KDL::ChainJntToJacSolver::JntToJac().
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.
F_a_b1 | frame b1 expressed with respect to some frame a. |
F_a_b2 | frame b2 expressed with respect to some frame a. |
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.
R_a_b1 | The rotation matrix \( _a^{b1} R \) of b1 with respect to frame a. |
R_a_b2 | The 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. |
IMETHOD VectorVel KDL::diff | ( | const RotationVel & | a, |
const RotationVel & | b, | ||
double | dt = 1.0 ) |
References diff(), KDL::RotationVel::R, and KDL::RotationVel::w.
determines the difference between two twists i.e.
the difference between the underlying velocity vectors and rotational velocity vectors.
determines the difference of vector b with vector a.
see diff for Rotation matrices for further background information.
p_w_a | start vector a expressed to some frame w |
p_w_b | end vector b expressed to some frame w . |
dt | [optional][obsolete] time interval over which the numerical differentiation takes place. |
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().
References diff(), KDL::VectorVel::p, and KDL::VectorVel::v.
determines the difference between two wrenches i.e.
the difference between the underlying torque vectors and force vectors.
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.
src | A |
factor | b |
dest | C |
Referenced by Divide().
void KDL::Divide | ( | const JntArrayAcc & | src, |
const double & | factor, | ||
JntArrayAcc & | dest ) |
void KDL::Divide | ( | const JntArrayAcc & | src, |
const doubleAcc & | factor, | ||
JntArrayAcc & | dest ) |
void KDL::Divide | ( | const JntArrayAcc & | src, |
const doubleVel & | factor, | ||
JntArrayAcc & | dest ) |
void KDL::Divide | ( | const JntArrayVel & | src, |
const double & | factor, | ||
JntArrayVel & | dest ) |
void KDL::Divide | ( | const JntArrayVel & | src, |
const doubleVel & | factor, | ||
JntArrayVel & | dest ) |
void KDL::Divide | ( | const JntSpaceInertiaMatrix & | src, |
const double & | factor, | ||
JntSpaceInertiaMatrix & | dest ) |
References Divide().
It compares whether the 2 arguments are equal in an eps-interval
Referenced by KDL::ChainIkSolverPos_NR::CartToJnt(), and KDL::ChainIkSolverPos_NR_JL::CartToJnt().
Function to check if two arrays are the same with a precision of eps.
src1 | |
src2 | |
eps | default: epsilon |
bool KDL::Equal | ( | const JntArrayAcc & | src1, |
const JntArrayAcc & | src2, | ||
double | eps = epsilon ) |
bool KDL::Equal | ( | const JntArrayVel & | src1, |
const JntArrayVel & | src2, | ||
double | eps = epsilon ) |
bool KDL::Equal | ( | const JntSpaceInertiaMatrix & | src1, |
const JntSpaceInertiaMatrix & | src2, | ||
double | eps ) |
It compares whether the 2 arguments are equal in an eps-interval
bool KDL::Equal | ( | const Rotation & | r1, |
const RotationAcc & | r2, | ||
double | eps = epsilon ) |
bool KDL::Equal | ( | const Rotation & | r1, |
const RotationVel & | r2, | ||
double | eps = epsilon ) |
It compares whether the 2 arguments are equal in an eps-interval
bool KDL::Equal | ( | const RotationAcc & | r1, |
const Rotation & | r2, | ||
double | eps = epsilon ) |
bool KDL::Equal | ( | const RotationAcc & | r1, |
const RotationAcc & | r2, | ||
double | eps = epsilon ) |
bool KDL::Equal | ( | const RotationVel & | r1, |
const Rotation & | r2, | ||
double | eps = epsilon ) |
bool KDL::Equal | ( | const RotationVel & | r1, |
const RotationVel & | r2, | ||
double | eps = epsilon ) |
It compares whether the 2 arguments are equal in an eps-interval
It compares whether the 2 arguments are equal in an eps-interval
It compares whether the 2 arguments are equal in an eps-interval
It compares whether the 2 arguments are equal in an eps-interval
|
inlinestatic |
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.
src | A |
factor | b |
dest | C |
Referenced by KDL::TreeIkSolverPos_Online::enforceJointVelLimits(), Multiply(), and Multiply().
void KDL::Multiply | ( | const JntArrayAcc & | src, |
const double & | factor, | ||
JntArrayAcc & | dest ) |
void KDL::Multiply | ( | const JntArrayAcc & | src, |
const doubleAcc & | factor, | ||
JntArrayAcc & | dest ) |
void KDL::Multiply | ( | const JntArrayAcc & | src, |
const doubleVel & | factor, | ||
JntArrayAcc & | dest ) |
void KDL::Multiply | ( | const JntArrayVel & | src, |
const double & | factor, | ||
JntArrayVel & | dest ) |
void KDL::Multiply | ( | const JntArrayVel & | src, |
const doubleVel & | factor, | ||
JntArrayVel & | dest ) |
void KDL::Multiply | ( | const JntSpaceInertiaMatrix & | src, |
const double & | factor, | ||
JntSpaceInertiaMatrix & | dest ) |
References Multiply().
References KDL::JntArray::data, and Multiply().
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
jac | J |
src | q |
dest | t |
Referenced by KDL::ChainJntToJacDotSolver::JntToJacDot().
bool KDL::operator!= | ( | const Rotation & | r1, |
const RotationVel & | r2 ) |
bool KDL::operator!= | ( | const RotationVel & | r1, |
const Rotation & | r2 ) |
bool KDL::operator!= | ( | const RotationVel & | r1, |
const RotationVel & | r2 ) |
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
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.
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
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
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.
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
RotationAcc KDL::operator* | ( | const Rotation & | r1, |
const RotationAcc & | r2 ) |
RotationVel KDL::operator* | ( | const Rotation & | r1, |
const RotationVel & | r2 ) |
RotationAcc KDL::operator* | ( | const RotationAcc & | r1, |
const Rotation & | r2 ) |
RotationAcc KDL::operator* | ( | const RotationAcc & | r1, |
const RotationAcc & | r2 ) |
RotationVel KDL::operator* | ( | const RotationVel & | r1, |
const Rotation & | r2 ) |
RotationVel KDL::operator* | ( | const RotationVel & | r1, |
const RotationVel & | r2 ) |
ArticulatedBodyInertia KDL::operator* | ( | double | a, |
const ArticulatedBodyInertia & | I ) |
Scalar product: I_new = double * I_old.
RigidBodyInertia KDL::operator* | ( | double | a, |
const RigidBodyInertia & | I ) |
Scalar product: I_new = double * I_old.
Scalar product.
RotationalInertia KDL::operator* | ( | double | a, |
const RotationalInertia & | I ) |
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
ArticulatedBodyInertia KDL::operator+ | ( | const ArticulatedBodyInertia & | Ia, |
const RigidBodyInertia & | Ib ) |
ArticulatedBodyInertia KDL::operator+ | ( | const RigidBodyInertia & | Ia, |
const ArticulatedBodyInertia & | Ib ) |
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
RotationalInertia KDL::operator+ | ( | const RotationalInertia & | Ia, |
const RotationalInertia & | Ib ) |
ArticulatedBodyInertia KDL::operator- | ( | const ArticulatedBodyInertia & | Ia, |
const ArticulatedBodyInertia & | Ib ) |
ArticulatedBodyInertia KDL::operator- | ( | const ArticulatedBodyInertia & | Ia, |
const RigidBodyInertia & | Ib ) |
ArticulatedBodyInertia KDL::operator- | ( | const RigidBodyInertia & | Ia, |
const ArticulatedBodyInertia & | Ib ) |
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
const Chain & | chain ) |
References KDL::Chain::getNrOfSegments(), and KDL::Chain::getSegment().
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
const Frame & | T ) |
References KDL::Frame::M, and KDL::Frame::p.
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
const Frame2 & | T ) |
References KDL::Frame2::M, and KDL::Frame2::p.
|
inline |
References KDL::FrameAcc::M, and KDL::FrameAcc::p.
|
inline |
References KDL::FrameVel::M, and KDL::FrameVel::p.
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
const Jacobian & | jac ) |
References KDL::Jacobian::columns(), and KDL::Jacobian::rows().
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
const JntArray & | array ) |
References KDL::JntArray::rows().
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
const JntSpaceInertiaMatrix & | jntspaceinertiamatrix ) |
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
const Joint & | joint ) |
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
const Rotation & | R ) |
References KDL::Rotation::GetEulerZYX(), and KDL::Rotation::GetRPY().
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
const Rotation2 & | R ) |
References KDL::Rotation2::GetRot().
|
inline |
References KDL::RotationAcc::dw, KDL::RotationAcc::R, and KDL::RotationAcc::w.
|
inline |
References KDL::RotationVel::R, and KDL::RotationVel::w.
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
const Segment & | segment ) |
References KDL::Segment::getFrameToTip(), KDL::Segment::getJoint(), and KDL::Segment::getName().
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
const Tree & | tree ) |
References KDL::Tree::getRootSegment().
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
const Twist & | v ) |
References KDL::Twist::rot, and KDL::Twist::vel.
|
inline |
References KDL::TwistAcc::rot, and KDL::TwistAcc::vel.
|
inline |
References KDL::TwistVel::rot, and KDL::TwistVel::vel.
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
const Vector & | v ) |
width to be used when printing variables out with frames_io.h global variable, can be changed.
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
const Vector2 & | v ) |
|
inline |
References KDL::VectorAcc::dv, KDL::VectorAcc::p, and KDL::VectorAcc::v.
|
inline |
References KDL::VectorVel::p, and KDL::VectorVel::v.
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
const Wrench & | v ) |
References KDL::Wrench::force, and KDL::Wrench::torque.
std::ostream & KDL::operator<< | ( | std::ostream & | os, |
SegmentMap::const_iterator | root ) |
References GetTreeElementChildren, and GetTreeElementQNr.
bool KDL::operator== | ( | const JntSpaceInertiaMatrix & | src1, |
const JntSpaceInertiaMatrix & | src2 ) |
References Equal().
bool KDL::operator== | ( | const Rotation & | r1, |
const RotationVel & | r2 ) |
bool KDL::operator== | ( | const RotationVel & | r1, |
const Rotation & | r2 ) |
bool KDL::operator== | ( | const RotationVel & | r1, |
const RotationVel & | r2 ) |
std::istream & KDL::operator>> | ( | std::istream & | is, |
Chain & | chain ) |
std::istream & KDL::operator>> | ( | std::istream & | is, |
Frame & | T ) |
References KDL::Frame::DH(), KDL::Frame::M, and KDL::Frame::p.
std::istream & KDL::operator>> | ( | std::istream & | is, |
Frame2 & | T ) |
References KDL::Frame2::M, and KDL::Frame2::p.
std::istream & KDL::operator>> | ( | std::istream & | is, |
Jacobian & | jac ) |
std::istream & KDL::operator>> | ( | std::istream & | is, |
JntArray & | array ) |
std::istream & KDL::operator>> | ( | std::istream & | is, |
JntSpaceInertiaMatrix & | jntspaceinertiamatrix ) |
std::istream & KDL::operator>> | ( | std::istream & | is, |
Joint & | joint ) |
std::istream & KDL::operator>> | ( | std::istream & | is, |
Rotation & | r ) |
std::istream & KDL::operator>> | ( | std::istream & | is, |
Rotation2 & | r ) |
References KDL::Rotation2::Rot().
std::istream & KDL::operator>> | ( | std::istream & | is, |
Segment & | segment ) |
std::istream & KDL::operator>> | ( | std::istream & | is, |
Tree & | tree ) |
std::istream & KDL::operator>> | ( | std::istream & | is, |
Twist & | v ) |
References KDL::Twist::rot, and KDL::Twist::vel.
std::istream & KDL::operator>> | ( | std::istream & | is, |
Vector & | v ) |
References KDL::Vector::Zero().
std::istream & KDL::operator>> | ( | std::istream & | is, |
Vector2 & | v ) |
std::istream & KDL::operator>> | ( | std::istream & | is, |
Wrench & | v ) |
References KDL::Wrench::force, and KDL::Wrench::torque.
IMETHOD void KDL::posrandom | ( | doubleVel & | F | ) |
IMETHOD void KDL::posrandom | ( | Frame & | F | ) |
IMETHOD void KDL::posrandom | ( | FrameVel & | F | ) |
IMETHOD void KDL::posrandom | ( | Rotation & | R | ) |
IMETHOD void KDL::posrandom | ( | RotationVel & | R | ) |
|
inline |
References posrandom().
IMETHOD void KDL::posrandom | ( | Twist & | a | ) |
IMETHOD void KDL::posrandom | ( | TwistVel & | a | ) |
IMETHOD void KDL::posrandom | ( | Vector & | a | ) |
Referenced by posrandom(), posrandom(), and random().
IMETHOD void KDL::posrandom | ( | VectorVel & | a | ) |
References KDL::VectorVel::p, posrandom(), and KDL::VectorVel::v.
IMETHOD void KDL::posrandom | ( | Wrench & | a | ) |
IMETHOD void KDL::random | ( | doubleVel & | F | ) |
IMETHOD void KDL::random | ( | Frame & | F | ) |
IMETHOD void KDL::random | ( | FrameVel & | F | ) |
IMETHOD void KDL::random | ( | Rotation & | R | ) |
IMETHOD void KDL::random | ( | RotationVel & | R | ) |
References KDL::RotationVel::R, and random().
|
inline |
References posrandom().
IMETHOD void KDL::random | ( | Twist & | a | ) |
IMETHOD void KDL::random | ( | TwistVel & | a | ) |
References random(), KDL::TwistVel::rot, and KDL::TwistVel::vel.
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().
a | : displacement rotational velocity |
da | : rotational velocity |
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().
a | : displacement twist |
da | : 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)); }
IMETHOD void KDL::random | ( | VectorVel & | a | ) |
IMETHOD void KDL::random | ( | Wrench & | a | ) |
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
void KDL::SetToZero | ( | Jacobian & | jac | ) |
void KDL::SetToZero | ( | JntArray & | array | ) |
Function to set all the values of the array to 0.
array |
void KDL::SetToZero | ( | JntArrayAcc & | array | ) |
void KDL::SetToZero | ( | JntArrayVel & | array | ) |
void KDL::SetToZero | ( | JntSpaceInertiaMatrix & | mat | ) |
IMETHOD void KDL::SetToZero | ( | Twist & | v | ) |
void KDL::SetToZero | ( | TwistVel & | v | ) |
IMETHOD void KDL::SetToZero | ( | Vector & | v | ) |
Referenced by KDL::ChainJntToJacDotSolver::getPartialDerivative(), KDL::ChainJntToJacDotSolver::getPartialDerivativeBodyFixed(), KDL::ChainJntToJacDotSolver::getPartialDerivativeHybrid(), KDL::ChainJntToJacDotSolver::getPartialDerivativeInertial(), KDL::ChainDynParam::JntToCoriolis(), KDL::ChainDynParam::JntToGravity(), KDL::ChainJntToJacSolver::JntToJac(), KDL::TreeJntToJacSolver::JntToJac(), KDL::ChainJntToJacDotSolver::JntToJacDot(), and KDL::ChainExternalWrenchEstimator::setInitialMomentum().
IMETHOD void KDL::SetToZero | ( | Vector2 & | v | ) |
void KDL::SetToZero | ( | VectorVel & | v | ) |
IMETHOD void KDL::SetToZero | ( | Wrench & | v | ) |
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.
src1 | A |
src2 | B |
dest | C |
Referenced by Subtract().
void KDL::Subtract | ( | const JntArrayAcc & | src1, |
const JntArray & | src2, | ||
JntArrayAcc & | dest ) |
void KDL::Subtract | ( | const JntArrayAcc & | src1, |
const JntArrayAcc & | src2, | ||
JntArrayAcc & | dest ) |
void KDL::Subtract | ( | const JntArrayAcc & | src1, |
const JntArrayVel & | src2, | ||
JntArrayAcc & | dest ) |
void KDL::Subtract | ( | const JntArrayVel & | src1, |
const JntArray & | src2, | ||
JntArrayVel & | dest ) |
void KDL::Subtract | ( | const JntArrayVel & | src1, |
const JntArrayVel & | src2, | ||
JntArrayVel & | dest ) |
void KDL::Subtract | ( | const JntSpaceInertiaMatrix & | src1, |
const JntSpaceInertiaMatrix & | src2, | ||
JntSpaceInertiaMatrix & | dest ) |
References Subtract().
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)
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. |
Referenced by KDL::ChainIkSolverVel_pinv_givens::CartToJnt().
std::string KDL::tree2str | ( | const SegmentMap::const_iterator | it, |
const std::string & | separator, | ||
const std::string & | preamble, | ||
unsigned int | level ) |
References GetTreeElementChildren, GetTreeElementQNr, and tree2str().
Referenced by tree2str(), and tree2str().
std::string KDL::tree2str | ( | const Tree & | tree, |
const std::string & | separator, | ||
const std::string & | preamble ) |
References KDL::Tree::getRootSegment(), and tree2str().
|
inline |
References KDL::Vector::data, KDL::Twist::rot, and KDL::Twist::vel.
Referenced by KDL::ChainIkSolverPos_LMA::CartToJnt().
|
static |
Referenced by KDL::RigidBodyInertia::RefPoint().