ROS Resources: Documentation | Support | Discussion Forum | Index | Service Status | ros @ Robotics Stack Exchange
Ask Your Question

Revision history [back]

Here is an overview of the different libraries I am aware of.


Robotics algorithms

  • Forward (or direct) geometry: from joint configuration to body position,
  • Forward (or direct) kinematics: from joint velocity to body velocity,
  • Inverse kinematics: from body velocity to joint velocity,
  • Forward (or direct) dynamics: from forces applied on a body compute the body acceleration,
  • Inverse dynamics: from body accelerations compute forces applied by the joints (RNEA).

For any of these algorithms, one may support or not:

  • floating-base (through the addition of a free-flyer joint as the root joint of the model)
  • particular structures such as trees (instead of chains) and closed-loops,
  • external forces (for dynamics related algorithms). For instance, it is useful to take into account external disturbances during motion.

More information:


KDL (Orocos)

The Kinematics and Dynamics library used by ROS core packages. Notably the robot_model one.

Algorithms:

Supported joints:

  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)

Features:

  • License: LGPL
  • Underlying matrix library: none, uses its own types,
  • Frame representation: rotation matrix and translation vector,
  • Online model edition: yes,
  • Tree support: NO,
  • Floating base support: NO (only 1-dof joints),
  • URDF loading: yes, separate ROS package kdl_parser, read only.

Links:


Metapod

Metapod is a meta-programming dynamics computation library. The objective is to achieve high efficiency by assuming the robot model is known at compile-time. By doing so and by relying on advanced C++ techniques, dynamic allocation can be totally avoided and the compiler can achieve optimization that would not be possible in any other case.

Algorithms:

  • Geometry: NO
  • Kinematics: NO
  • Dynamics: Inverse

Supported joints:

  • 1-dof: revolute (X or any arbitrary axis)
  • 6-dof: free-floating (three translation, three rotation)

Features:

  • License: LGPL3
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (rotation matrix and translation vector),
  • Online model edition: NO,
  • Tree support: yes,
  • Floating base support: yes,
  • URDF support: yes, experimental, read only[1].

[1] This Python script lives as a specific branch of robot_model_py for now. Due to Metapod specific design, loading an URDF model means in this context generating a C++ file which then will be compiled to use the robot-specific dynamic algorithm (RNEA).

Links:


RBDL (Rigid Body Dynamics Library)

A modern implementation of Roy Featherstone's book based on Eigen.

Algorithms:

Supported joints:

  • 0-dof: anchor
  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)
  • 2-dof: generic (only pure rotation or pure translation)
  • 4-dof: generic (only pure rotation or pure translation)
  • 5-dof: generic (only pure rotation or pure translation)
  • 6-dof: generic (only pure rotation or pure translation)

Features:

  • License: zlib
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (underlying frame representation is rotation matrix and translation vector),
  • Online model edition: yes,
  • Tree support: yes,
  • Floating base support: NO (6-dof joint cannot handle mixed rotation/translation),
  • URDF support: yes, optional, read only.

Links:


Sympybotics [Python]

Algorithms:

  • Geometry: direct
  • Kinematics: direct, inverse
  • Dynamics: direct, inverse

Supported joints:

Features:

  • License: GPL2
  • Underlying matrix library: Numpy,
  • Frame representation: homogeneous matrices (4x4),
  • Online model edition: yes (but requires code regeneration which is possibly time-consuming),
  • Tree support: yes,
  • Floating base support: NO,
  • URDF support: NO.

Links:


Other libraries

Here is an overview a review of the different libraries I am aware of.of. I hope it will help you make your choice!


Robotics algorithms

  • Forward (or direct) geometry: from joint configuration to body position,
  • Forward (or direct) kinematics: from joint velocity to body velocity,
  • Inverse kinematics: from body velocity to joint velocity,
  • Forward (or direct) dynamics: from forces applied on a body compute the body acceleration,
  • Inverse dynamics: from body accelerations compute forces applied by the joints (RNEA).

For any of these algorithms, one may support or not:

  • floating-base (through the addition of a free-flyer joint as the root joint of the model)
  • particular structures such as trees (instead of chains) and closed-loops,
  • external forces (for dynamics related algorithms). For instance, it is useful to take into account external disturbances during motion.

More information:


KDL (Orocos)

The Kinematics and Dynamics library used by ROS core packages. Notably the robot_model one.

Algorithms:

Supported joints:

  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)

Features:

  • License: LGPL
  • Underlying matrix library: none, uses its own types,
  • Frame representation: rotation matrix and translation vector,
  • Online model edition: yes,
  • Tree support: NO,
  • Floating base support: NO (only 1-dof joints),
  • URDF loading: yes, separate ROS package kdl_parser, read only.

Links:


Metapod

Metapod is a meta-programming dynamics computation library. The objective is to achieve high efficiency by assuming the robot model is known at compile-time. By doing so and by relying on advanced C++ techniques, dynamic allocation can be totally avoided and the compiler can achieve optimization that would not be possible in any other case.

Algorithms:

  • Geometry: NO
  • Kinematics: NO
  • Dynamics: Inverse

Supported joints:

  • 1-dof: revolute (X or any arbitrary axis)
  • 6-dof: free-floating (three translation, three rotation)

Features:

  • License: LGPL3
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (rotation matrix and translation vector),
  • Online model edition: NO,
  • Tree support: yes,
  • Floating base support: yes,
  • URDF support: yes, experimental, read only[1].

[1] This Python script lives as a specific branch of robot_model_py for now. Due to Metapod specific design, loading an URDF model means in this context generating a C++ file which then will be compiled to use the robot-specific dynamic algorithm (RNEA).

Links:


RBDL (Rigid Body Dynamics Library)

A modern implementation of Roy Featherstone's book based on Eigen.

Algorithms:

Supported joints:

  • 0-dof: anchor
  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)
  • 2-dof: generic (only pure rotation or pure translation)
  • 4-dof: generic (only pure rotation or pure translation)
  • 5-dof: generic (only pure rotation or pure translation)
  • 6-dof: generic (only pure rotation or pure translation)

Features:

  • License: zlib
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (underlying frame representation is rotation matrix and translation vector),
  • Online model edition: yes,
  • Tree support: yes,
  • Floating base support: NO (6-dof joint cannot handle mixed rotation/translation),
  • URDF support: yes, optional, read only.

Links:


Sympybotics [Python]

Algorithms:

  • Geometry: direct
  • Kinematics: direct, inverse
  • Dynamics: direct, inverse

Supported joints:

Features:

  • License: GPL2
  • Underlying matrix library: Numpy,
  • Frame representation: homogeneous matrices (4x4),
  • Online model edition: yes (but requires code regeneration which is possibly time-consuming),
  • Tree support: yes,
  • Floating base support: NO,
  • URDF support: NO.

Links:


Other libraries

Here is a review of the libraries I am aware of. I hope it will help you make your choice!


Robotics algorithms

  • Forward (or direct) geometry: from joint configuration to body position,
  • Forward (or direct) kinematics: from joint velocity to body velocity,
  • Inverse kinematics: from body velocity to joint velocity,
  • Forward (or direct) dynamics: from forces applied on a body compute the body acceleration,
  • Inverse dynamics: from body accelerations compute forces applied by the joints (RNEA).

For any of these algorithms, one may support or not:

  • floating-base (through the addition of a free-flyer joint as the root joint of the model)
  • particular structures such as trees (instead of chains) and closed-loops,
  • external forces (for dynamics related algorithms). For instance, it is useful to take into account external disturbances during motion.

More information:


KDL (Orocos)

The Kinematics and Dynamics library used by ROS core packages. Notably the robot_model one.

Algorithms:

Supported joints:

  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)

Features:

  • License: LGPL
  • Underlying matrix library: none, uses its own types,
  • Frame representation: rotation matrix and translation vector,
  • Online model edition: yes,
  • Tree support: NO,
  • Floating base support: NO (only 1-dof joints),
  • URDF loading: yes, separate ROS package kdl_parser, read only.

Links:


Metapod

Metapod is a meta-programming dynamics computation library. The objective is to achieve high efficiency by assuming the robot model is known at compile-time. By doing so and by relying on advanced C++ techniques, dynamic allocation can be totally avoided and the compiler can achieve optimization that would not be possible in any other case.

Algorithms:

  • Geometry: NO
  • Kinematics: NO
  • Dynamics: Inverse

Supported joints:

  • 1-dof: revolute (X or any arbitrary axis)
  • 6-dof: free-floating (three translation, three rotation)

Features:

  • License: LGPL3
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (rotation matrix and translation vector),
  • Online model edition: NO,
  • Tree support: yes,
  • Floating base support: yes,
  • URDF support: yes, experimental, read only[1].

[1] This Python script lives as a specific branch of robot_model_py for now. Due to Metapod specific design, loading an URDF model means in this context generating a C++ file which then will be compiled to use the robot-specific dynamic algorithm (RNEA).

Links:


RBDL (Rigid Body Dynamics Library)

A modern implementation of Roy Featherstone's book based on Eigen.

Algorithms:

Supported joints:

  • 0-dof: anchor
  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)
  • 2-dof: generic (only pure rotation or pure translation)
  • 4-dof: generic (only pure rotation or pure translation)
  • 5-dof: generic (only pure rotation or pure translation)
  • 6-dof: generic (only pure rotation or pure translation)

Features:

  • License: zlib
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (underlying frame representation is rotation matrix and translation vector),
  • Online model edition: yes,
  • Tree support: yes,
  • Floating base support: NO (6-dof joint cannot handle mixed rotation/translation),
  • URDF support: yes, optional, read only.

Links:


Sympybotics [Python]

Algorithms:

  • Geometry: direct
  • Kinematics: direct, inverse
  • Dynamics: direct, inverse

Supported joints:

Features:

  • License: GPL2
  • Underlying matrix library: Numpy,
  • Frame representation: homogeneous matrices (4x4),
  • Online model edition: yes (but requires code regeneration which is possibly time-consuming),
  • Tree support: yes,
  • Floating base support: NO,
  • URDF support: NO.

Links:


Other libraries

Here is a review of the libraries I am aware of. I hope it will help you make your choice!


Robotics algorithms

  • Forward (or direct) geometry: from joint configuration to body position,
  • Forward (or direct) kinematics: from joint velocity to body velocity,
  • Inverse kinematics: from body velocity to joint velocity,
  • Forward (or direct) dynamics: from forces applied on a body compute the body acceleration,
  • Inverse dynamics: from body accelerations compute forces applied by the joints (RNEA).

For any of these algorithms, one may support or not:

  • floating-base (through the addition of a free-flyer joint as the root joint of the model)
  • particular structures such as trees (instead of chains) and closed-loops,
  • external forces (for dynamics related algorithms). For instance, it is useful to take into account external disturbances during motion.

More information:


KDL (Orocos)

The Kinematics and Dynamics library used by ROS core packages. Notably the robot_model one.

Algorithms:

Supported joints:

  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)

Features:

  • License: LGPL
  • Underlying matrix library: none, uses its own types,
  • Frame representation: rotation matrix and translation vector,
  • Online model edition: yes,
  • Tree support: NO,
  • Floating base support: NO (only 1-dof joints),
  • URDF loading: yes, separate ROS package kdl_parser, read only.

Links:


Metapod

Metapod is a meta-programming dynamics computation library. The objective is to achieve high efficiency by assuming the robot model is known at compile-time. By doing so and by relying on advanced C++ techniques, dynamic allocation can be totally avoided and the compiler can achieve optimization that would not be possible in any other case.

Algorithms:

  • Geometry: NODirect[1]
  • Kinematics: NODirect[1]
  • Dynamics: Inverse

[1] Those two algorithms are currently bound to the RNEA algorithm which means it is not possible currently to compute these quantities without computing the dynamics information.

Supported joints:

  • 1-dof: revolute (X or any arbitrary axis)
  • 6-dof: free-floating (three translation, three rotation)

Features:

  • License: LGPL3
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (rotation matrix and translation vector),
  • Online model edition: NO,
  • Tree support: yes,
  • Floating base support: yes,
  • URDF support: yes, experimental, read only[1].

[1] This Python script lives as a specific branch of robot_model_py for now. Due to Metapod specific design, loading an URDF model means in this context generating a C++ file which then will be compiled to use the robot-specific dynamic algorithm (RNEA).

Links:


RBDL (Rigid Body Dynamics Library)

A modern implementation of Roy Featherstone's book based on Eigen.

Algorithms:

Supported joints:

  • 0-dof: anchor
  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)
  • 2-dof: generic (only pure rotation or pure translation)translation) [1]
  • 4-dof: generic (only pure rotation or pure translation)translation) [1]
  • 5-dof: generic (only pure rotation or pure translation)translation) [1]
  • 6-dof: generic (only pure rotation or pure translation)
translation) [1]

[1] These are handled through the composition of 1-dof joints + null mass bodies which makes the algorithm slower than what is possible when dealing with these kind of joints.

Features:

  • License: zlib
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (underlying frame representation is rotation matrix and translation vector),
  • Online model edition: yes,
  • Tree support: yes,
  • Floating base support: NO (6-dof joint cannot handle mixed rotation/translation),
  • URDF support: yes, optional, experimental/optional, read only.

Links:


Sympybotics [Python]

Algorithms:

  • Geometry: direct
  • Kinematics: direct, inverse
  • Dynamics: direct, inverse

Supported joints:

Features:

  • License: GPL2
  • Underlying matrix library: Numpy,
  • Frame representation: homogeneous matrices (4x4),
  • Online model edition: yes (but requires code regeneration which is possibly time-consuming),
  • Tree support: yes,
  • Floating base support: NO,
  • URDF support: NO.

Links:


Other libraries

Thanks to Antonio El Khoury for his feedbacks and knowledge regarding state-of-the-Art dynamics libraries.

Here is a review of the libraries I am aware of. I hope it will help you make your choice!


Robotics algorithms

  • Forward (or direct) geometry: from joint configuration to body position,
  • Forward (or direct) kinematics: from joint velocity to body velocity,
  • Inverse kinematics: from body velocity to joint velocity,
  • Forward (or direct) dynamics: from forces applied on a body compute the body acceleration,
  • Inverse dynamics: from body accelerations compute forces applied by the joints (RNEA).

For any of these algorithms, one may support or not:

  • floating-base (through the addition of a free-flyer joint as the root joint of the model)
  • particular structures such as trees (instead of chains) and closed-loops,
  • external forces (for dynamics related algorithms). For instance, it is useful to take into account external disturbances during motion.

More information:


KDL (Orocos)

The Kinematics and Dynamics library used by ROS core packages. Notably the robot_model one.

Algorithms:

Supported joints:

  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)

Features:

  • License: LGPL
  • Underlying matrix library: none, uses its own types,
  • Frame representation: rotation matrix and translation vector,
  • Online model edition: yes,
  • Tree support: NO,
  • Floating base support: NO (only 1-dof joints),
  • URDF loading: yes, separate ROS package kdl_parser, read only.

Links:


Metapod

Metapod is a meta-programming dynamics computation library. The objective is to achieve high efficiency by assuming the robot model is known at compile-time. By doing so and by relying on advanced C++ techniques, dynamic allocation can be totally avoided and the compiler can achieve optimization that would not be possible in any other case.

Algorithms:

  • Geometry: Direct[1]
  • Kinematics: Direct[1]
  • Dynamics: Inverse

[1] Those two algorithms are currently bound to the RNEA algorithm which means it is not possible currently to compute these quantities without computing the dynamics information.

Supported joints:

  • 1-dof: revolute (X or any arbitrary axis)
  • 6-dof: free-floating (three translation, three rotation)

Features:

  • License: LGPL3
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (rotation matrix and translation vector),
  • Online model edition: NO,
  • Tree support: yes,
  • Floating base support: yes,
  • URDF support: yes, experimental, read only[1].

[1] This Python script lives as a specific branch of robot_model_py for now. Due to Metapod specific design, loading an URDF model means in this context generating a C++ file which then will be compiled to use the robot-specific dynamic algorithm (RNEA).

Links:


RBDL (Rigid Body Dynamics Library)

A modern implementation of Roy Featherstone's book based on Eigen.

Algorithms:

Supported joints:

  • 0-dof: anchor
  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)
  • 2-dof: generic (only pure rotation or pure translation) [1]
  • 4-dof: generic (only pure rotation or pure translation) [1]
  • 5-dof: generic (only pure rotation or pure translation) [1]
  • 6-dof: generic (only pure rotation or pure translation) [1]

[1] These are handled through the composition of 1-dof joints (revolute or prismatic) + null mass bodies which which makes the algorithm algorithms slower than what is possible when dealing with these kind of joints.

Features:

  • License: zlib
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (underlying frame representation is rotation matrix and translation vector),
  • Online model edition: yes,
  • Tree support: yes,
  • Floating base support: NO (6-dof joint cannot handle mixed rotation/translation),
  • URDF support: yes, experimental/optional, read only.

Links:


Sympybotics [Python]

Algorithms:

  • Geometry: direct
  • Kinematics: direct, inverse
  • Dynamics: direct, inverse

Supported joints:

Features:

  • License: GPL2
  • Underlying matrix library: Numpy,
  • Frame representation: homogeneous matrices (4x4),
  • Online model edition: yes (but requires code regeneration which is possibly time-consuming),
  • Tree support: yes,
  • Floating base support: NO,
  • URDF support: NO.

Links:


Other libraries

Thanks to Antonio El Khoury for his feedbacks and knowledge regarding state-of-the-Art dynamics libraries.

Here is a review of the libraries I am aware of. I hope it will help you make your choice!


Robotics algorithms

  • Forward (or direct) geometry: from joint configuration to body position,
  • Forward (or direct) kinematics: from joint velocity to body velocity,
  • Inverse kinematics: from body velocity to joint velocity,
  • Forward (or direct) dynamics: from forces applied on a body compute the body acceleration,
  • Inverse dynamics: from body accelerations compute forces applied by the joints (RNEA).

For any of these algorithms, one may support or not:

  • floating-base (through the addition of a free-flyer joint as the root joint of the model)
  • particular structures such as trees (instead of chains) and closed-loops,
  • external forces (for dynamics related algorithms). For instance, it is useful to take into account external disturbances during motion.

More information:


KDL (Orocos)

The Kinematics and Dynamics library used by ROS core packages. Notably the robot_model one.

Algorithms:

Supported joints:

  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)

Features:

  • License: LGPL
  • Underlying matrix library: none, uses its own types,
  • Frame representation: rotation matrix and translation vector,
  • Online model edition: yes,
  • Tree support: NO,
  • Floating base support: NO (only 1-dof joints),
  • URDF loading: yes, separate ROS package kdl_parser, read only.

Links:


Metapod

Metapod is a meta-programming dynamics computation library. The objective is to achieve high efficiency by assuming the robot model is known at compile-time. By doing so and by relying on advanced C++ techniques, dynamic allocation can be totally avoided and the compiler can achieve optimization that would not be possible in any other case.

Algorithms:

  • Geometry: Direct[1]
  • Kinematics: Direct[1]
  • Dynamics: Inverse

[1] Those two algorithms are currently bound to the RNEA algorithm which means it is not possible currently to compute these quantities without computing the dynamics information.

Supported joints:

  • 1-dof: revolute (X or any arbitrary axis)
  • 6-dof: free-floating (three translation, three rotation)

Features:

  • License: LGPL3
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (rotation matrix and translation vector),
  • Online model edition: NO,
  • Tree support: yes,
  • Floating base support: yes,
  • URDF support: yes, experimental, read only[1].

[1] This Python script lives as a specific branch of robot_model_py for now. Due to Metapod specific design, loading an URDF model means in this context generating a C++ file which then will be compiled to use the robot-specific dynamic algorithm (RNEA).

Links:


OpenRAVE [C++, Python]

This motion planning library is able to provide kinematics and dynamics computation.

Algorithms:

  • Geometry: direct
  • Kinematics: direct, inverse
    • Dynamics: direct (?), inverse

Supported joints:

  • 1-dof: revolute, prismatic
  • 3-dof: sphere
  • 6-dof: free-floating
  • mimic joint

Features:

  • License: LGPL
  • Underlying matrix library:
    • C++: none, uses its own types,
    • Python: numpy,
  • Frame representation: quaternion and translation vector,
  • Online model edition: yes,
  • Tree support: yes,
  • Floating base support: yes,
  • URDF loading: NO (Collada support).

Links:


RBDL (Rigid Body Dynamics Library)

A modern implementation of Roy Featherstone's book based on Eigen.

Algorithms:

Supported joints:

  • 0-dof: anchor
  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)
  • 2-dof: generic [1]
  • 4-dof: generic [1]
  • 5-dof: generic [1]
  • 6-dof: generic [1]

[1] These are handled through the composition of 1-dof joints (revolute or prismatic) + null mass bodies which makes the algorithms slower than what is possible when dealing with these kind of joints.

Features:

  • License: zlib
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (underlying frame representation is rotation matrix and translation vector),
  • Online model edition: yes,
  • Tree support: yes,
  • Floating base support: NO (6-dof joint cannot handle mixed rotation/translation),
  • URDF support: yes, experimental/optional, read only.

Links:


Sympybotics [Python]

Algorithms:

  • Geometry: direct
  • Kinematics: direct, inverse
  • Dynamics: direct, inverse

Supported joints:

Features:

  • License: GPL2
  • Underlying matrix library: Numpy,
  • Frame representation: homogeneous matrices (4x4),
  • Online model edition: yes (but requires code regeneration which is possibly time-consuming),
  • Tree support: yes,
  • Floating base support: NO,
  • URDF support: NO.

Links:


Other libraries

Thanks to Antonio El Khoury for his feedbacks and knowledge regarding state-of-the-Art dynamics libraries.

Here is a review of the libraries I am aware of. I hope it will help you make your choice!


Robotics algorithms

  • Forward (or direct) geometry: from joint configuration to body position,
  • Forward (or direct) kinematics: from joint velocity to body velocity,
  • Inverse kinematics: from body velocity to joint velocity,
  • Forward (or direct) dynamics: from forces applied on a body compute the body acceleration,
  • Inverse dynamics: from body accelerations compute forces applied by the joints (RNEA).

For any of these algorithms, one may support or not:

  • floating-base (through the addition of a free-flyer joint as the root joint of the model)
  • particular structures such as trees (instead of chains) and closed-loops,
  • external forces (for dynamics related algorithms). For instance, it is useful to take into account external disturbances during motion.

More information:


Bullet (>= 2.82 / NEW)

Bullet Collision Detection & Physics SDK

Bullet is a Collision Detection and Rigid Body Dynamics Library. The Library is Open Source and free for commercial use, under the ZLib license.

Algorithms:

  • Geometry: unknown
  • Kinematics: unkown
  • Dynamics: forward, inverse

Supported joints:

  • 1-DOF revolute and prismatic joints

Features:

  • License: ZLib
  • Underlying matrix library: none, uses its own types,
  • Frame representation: rotation matrix and translation vector,
  • Online model edition: unknown,
  • Tree support: yes,
  • Floating base support: yes,
  • URDF loading: NO

Links:

KDL (Orocos)

The Kinematics and Dynamics library used by ROS core packages. Notably the robot_model one.

Algorithms:

Supported joints:

  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)

Features:

  • License: LGPL
  • Underlying matrix library: none, uses its own types,
  • Frame representation: rotation matrix and translation vector,
  • Online model edition: yes,
  • Tree support: NO,
  • Floating base support: NO (only 1-dof joints),
  • URDF loading: yes, separate ROS package kdl_parser, read only.

Links:


Metapod

Metapod is a meta-programming dynamics computation library. The objective is to achieve high efficiency by assuming the robot model is known at compile-time. By doing so and by relying on advanced C++ techniques, dynamic allocation can be totally avoided and the compiler can achieve optimization that would not be possible in any other case.

Algorithms:

  • Geometry: Direct[1]
  • Kinematics: Direct[1]
  • Dynamics: Inverse

[1] Those two algorithms are currently bound to the RNEA algorithm which means it is not possible currently to compute these quantities without computing the dynamics information.

Supported joints:

  • 1-dof: revolute (X or any arbitrary axis)
  • 6-dof: free-floating (three translation, three rotation)

Features:

  • License: LGPL3
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (rotation matrix and translation vector),
  • Online model edition: NO,
  • Tree support: yes,
  • Floating base support: yes,
  • URDF support: yes, experimental, read only[1].

[1] This Python script lives as a specific branch of robot_model_py for now. Due to Metapod specific design, loading an URDF model means in this context generating a C++ file which then will be compiled to use the robot-specific dynamic algorithm (RNEA).

Links:


OpenRAVE [C++, Python]

This motion planning library is able to provide kinematics and dynamics computation.

Algorithms:

  • Geometry: direct
  • Kinematics: direct, inverse
    • Dynamics: direct (?), inverse

Supported joints:

  • 1-dof: revolute, prismatic
  • 3-dof: sphere
  • 6-dof: free-floating
  • mimic joint

Features:

  • License: LGPL
  • Underlying matrix library:
    • C++: none, uses its own types,
    • Python: numpy,
  • Frame representation: quaternion and translation vector,
  • Online model edition: yes,
  • Tree support: yes,
  • Floating base support: yes,
  • URDF loading: NO (Collada support).

Links:


RBDL (Rigid Body Dynamics Library)

A modern implementation of Roy Featherstone's book based on Eigen.

Algorithms:

Supported joints:

  • 0-dof: anchor
  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)
  • 2-dof: generic [1]
  • 4-dof: generic [1]
  • 5-dof: generic [1]
  • 6-dof: generic [1]

[1] These are handled through the composition of 1-dof joints (revolute or prismatic) + null mass bodies which makes the algorithms slower than what is possible when dealing with these kind of joints.

Features:

  • License: zlib
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (underlying frame representation is rotation matrix and translation vector),
  • Online model edition: yes,
  • Tree support: yes,
  • Floating base support: NO (6-dof joint cannot handle mixed rotation/translation),
  • URDF support: yes, experimental/optional, read only.

Links:


Sympybotics [Python]

Algorithms:

  • Geometry: direct
  • Kinematics: direct, inverse
  • Dynamics: direct, inverse

Supported joints:

Features:

  • License: GPL2
  • Underlying matrix library: Numpy,
  • Frame representation: homogeneous matrices (4x4),
  • Online model edition: yes (but requires code regeneration which is possibly time-consuming),
  • Tree support: yes,
  • Floating base support: NO,
  • URDF support: NO.

Links:


Other libraries

Thanks to Antonio El Khoury for his feedbacks and knowledge regarding state-of-the-Art dynamics libraries.

Here is a review of the libraries I am aware of. I hope it will help you make your choice!


Robotics algorithms

  • Forward (or direct) geometry: from joint configuration to body position,
  • Forward (or direct) kinematics: from joint velocity to body velocity,
  • Inverse kinematics: from body velocity to joint velocity,
  • Forward (or direct) dynamics: from forces applied on a body compute the body acceleration,
  • Inverse dynamics: from body accelerations compute forces applied by the joints (RNEA).

For any of these algorithms, one may support or not:

  • floating-base (through the addition of a free-flyer joint as the root joint of the model)
  • particular structures such as trees (instead of chains) and closed-loops,
  • external forces (for dynamics related algorithms). For instance, it is useful to take into account external disturbances during motion.

More information:


Bullet (>= 2.82 / NEW)

Bullet Collision Detection & Physics SDK

Bullet is a Collision Detection and Rigid Body Dynamics Library. The Library is Open Source and free for commercial use, under the ZLib license.

Algorithms:

  • Geometry: unknown
  • Kinematics: unkown
  • Dynamics: forward, inverse

Supported joints:

  • 1-DOF revolute and prismatic joints

Features:

  • License: ZLib
  • Underlying matrix library: none, uses its own types,
  • Frame representation: rotation matrix and translation vector,
  • Online model edition: unknown,
  • Tree support: yes,
  • Floating base support: yes,
  • URDF loading: NO

Links:

KDL (Orocos)

The Kinematics and Dynamics library used by ROS core packages. Notably the robot_model one.

Algorithms:

Supported joints:

  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)

Features:

  • License: LGPL
  • Underlying matrix library: none, uses its own types,
  • Frame representation: rotation matrix and translation vector,
  • Online model edition: yes,
  • Tree support: NO,
  • Floating base support: NO (only 1-dof joints),
  • URDF loading: yes, separate ROS package kdl_parser, read only.

Links:


Metapod

Metapod is a meta-programming dynamics computation library. The objective is to achieve high efficiency by assuming the robot model is known at compile-time. By doing so and by relying on advanced C++ techniques, dynamic allocation can be totally avoided and the compiler can achieve optimization that would not be possible in any other case.

Algorithms:

  • Geometry: Direct[1]
  • Kinematics: Direct[1]
  • Dynamics: Inverse

[1] Those two algorithms are currently bound to the RNEA algorithm which means it is not possible currently to compute these quantities without computing the dynamics information.

Supported joints:

  • 1-dof: revolute (X or any arbitrary axis)
  • 6-dof: free-floating (three translation, three rotation)

Features:

  • License: LGPL3
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (rotation matrix and translation vector),
  • Online model edition: NO,
  • Tree support: yes,
  • Floating base support: yes,
  • URDF support: yes, experimental, read only[1].

[1] This Python script lives as a specific branch of robot_model_py for now. Due to Metapod specific design, loading an URDF model means in this context generating a C++ file which then will be compiled to use the robot-specific dynamic algorithm (RNEA).

Links:


OpenRAVE [C++, Python]

This motion planning library is able to provide kinematics and dynamics computation.

Algorithms:

  • Geometry: direct
  • Kinematics: direct, inverse
    • Dynamics: direct (?), inverse

Supported joints:

  • 1-dof: revolute, prismatic
  • 3-dof: sphere
  • 6-dof: free-floating
  • mimic joint

Features:

  • License: LGPL
  • Underlying matrix library:
    • C++: none, uses its own types,
    • Python: numpy,
  • Frame representation: quaternion and translation vector,
  • Online model edition: yes,
  • Tree support: yes,
  • Floating base support: yes,
  • URDF loading: NO (Collada support).support, URDF can be converted to Collada).

Links:


RBDL (Rigid Body Dynamics Library)

A modern implementation of Roy Featherstone's book based on Eigen.

Algorithms:

Supported joints:

  • 0-dof: anchor
  • 1-dof: revolute (X or Y or Z), prismatic (X or Y or Z)
  • 2-dof: generic [1]
  • 4-dof: generic [1]
  • 5-dof: generic [1]
  • 6-dof: generic [1]

[1] These are handled through the composition of 1-dof joints (revolute or prismatic) + null mass bodies which makes the algorithms slower than what is possible when dealing with these kind of joints.

Features:

  • License: zlib
  • Underlying matrix library: Eigen,
  • Frame representation: spatial algebra (underlying frame representation is rotation matrix and translation vector),
  • Online model edition: yes,
  • Tree support: yes,
  • Floating base support: NO (6-dof joint cannot handle mixed rotation/translation),
  • URDF support: yes, experimental/optional, read only.

Links:


Sympybotics [Python]

Algorithms:

  • Geometry: direct
  • Kinematics: direct, inverse
  • Dynamics: direct, inverse

Supported joints:

Features:

  • License: GPL2
  • Underlying matrix library: Numpy,
  • Frame representation: homogeneous matrices (4x4),
  • Online model edition: yes (but requires code regeneration which is possibly time-consuming),
  • Tree support: yes,
  • Floating base support: NO,
  • URDF support: NO.

Links:


Other libraries

Thanks to Antonio El Khoury for his feedbacks and knowledge regarding state-of-the-Art dynamics libraries.