# Kinematic Trees - KDL 1.0.x

## KDL::Joint

A Joint allows translation or rotation in one degree of freedom between two Segments

### Creating Joints

```Joint rx = Joint(Joint::RotX);//Rotational Joint about X
Joint ry = Joint(Joint::RotY);//Rotational Joint about Y
Joint rz = Joint(Joint::RotZ);//Rotational Joint about Z
Joint tx = Joint(Joint::TransX);//Translational Joint along X
Joint ty = Joint(Joint::TransY);//Translational Joint along Y
Joint tz = Joint(Joint::TransZ);//Translational Joint along Z
Joint fixed = Joint(Joint::None);//Rigid Connection```
Note: See the API document for a full list of construction possibilities

### Pose and twist of a Joint

```Joint rx = Joint(Joint::RotX);
double q = M_PI/4;//Joint position
Frame f = rx.pose(q);
double qdot = 0.1;//Joint velocity
Twist t = rx.twist(qdot);```
f is the pose resulting from moving the joint from its zero position to a joint value q t is the twist expressed in the frame corresponding to the zero position of the joint, resulting from applying a joint speed qdot

## KDL::Segment

A Segment is an ideal rigid body to which one single Joint is connected and one single tip frame. It contains:

• a Joint located at the root frame of the Segment.
• a Frame describing the pose between the end of the Joint and the tip frame of the Segment.

### Creating Segments

```Segment s = Segment(Joint(Joint::RotX),
Frame(Rotation::RPY(0.0,M_PI/4,0.0),
Vector(0.1,0.2,0.3) )
);```
Note: The constructor takes copies of the arguments, you cannot change the frame or joint afterwards!!!

### Pose and twist of a Segment

```double q=M_PI/2;//joint position
Frame f = s.pose(q);//s constructed as in previous example
double qdot=0.1;//joint velocity
Twist t = s.twist(q,qdot);```
fis the pose resulting from moving the joint from its zero position to a joint value q and expresses the new tip frame wrt the root frame of the Segment s. t is the twist of the tip frame expressed in the root frame of the Segment s, resulting from applying a joint speed qdot at the joint value q

## KDL::Chain

A KDL::Chain is

• a kinematic description of a serial chain of bodies connected by joints.
• built out of KDL::Segments.

A Chain has

• a default constructor, creating an empty chain without any segments.
• a copy-constructor, creating a copy of an existing chain.
• a =-operator.

```Chain chain1;
Chain chain2(chain3);
Chain chain4 = chain5;```

Chains are constructed by adding segments or existing chains to the end of the chain. These functions add copies of the arguments, not the arguments themselves!

```chain1.addSegment(segment1);

You can get the number of joints and number of segments (this is not always the same since a segment can have a Joint::None, which is not included in the number of joints):

```unsigned int nj = chain1.getNrOfJoints();
unsigned int js = chain1.getNrOfSegments();```

You can iterate over the segments of a chain by getting a reference to each successive segment:

`Segment& segment3 = chain1.getSegment(3);`

## KDL::Tree

A KDL::Tree is

• a kinematic description of a tree of bodies connected by joints.
• built out of KDL::Segments.

A Tree has

• a constructor that creates an empty tree without any segments and with the given name as its root name. The root name will be "root" if no name is given.
• a copy-constructor, creating a copy of an existing tree.
• a =-operator

```Tree tree1;
Tree tree2("RootName");
Tree tree3(tree4);
Tree tree5 = tree6;```

Trees are constructed by adding segments, existing chains or existing trees to a given hook name. The methods will return false if the given hook name is not in the tree. These functions add copies of the arguments, not the arguments themselves!

```bool exit_value;

You can get the number of joints and number of segments (this is not always the same since a segment can have a fixed joint (Joint::None), which is not included in the number of joints):

```unsigned int nj = tree1.getNrOfJoints();
unsigned int js = tree1.getNrOfSegments();```

You can retrieve the root segment:

`std::map<std::string,TreeElement>::const_iterator root = tree1.getRootSegment();`

You can also retrieve a specific segment in a tree by its name:

`std::map<std::string,TreeElement>::const_iterator segment3 = tree1.getSegment("Segment 3");`

You can retrieve the segments in the tree:

`std::map<std::string,TreeElement>& segments = tree1.getSegments();`

It is possible to request the chain in a tree between a certain root and a tip:

```bool exit_value;
Chain chain;
exit_value = tree1.getChain("Segment 1","Segment 3",chain);
//Segment 1 and segment 3 are included but segment 1 is renamed.
Chain chain2;
exit_value = tree1.getChain("Segment 3","Segment 1",chain2);
//Segment 1 and segment 3 are included but segment 3 is renamed.```