Repository Summary
Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
VCS Type | git |
VCS Version | devel |
Last Updated | 2024-10-14 |
Dev Status | DEVELOPED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
Name | Version |
---|---|
pinocchio | 3.2.0 |
README
Pinocchio instantiates the state-of-the-art Rigid Body Algorithms for poly-articulated systems based on revisited Roy Featherstone’s algorithms. Besides, Pinocchio provides the analytical derivatives of the main Rigid-Body Algorithms, such as the Recursive Newton-Euler Algorithm or the Articulated-Body Algorithm.
Pinocchio was first tailored for robotics applications, but it can be used in other contexts (biomechanics, computer graphics, vision, etc.). It is built upon Eigen for linear algebra and FCL for collision detection. Pinocchio comes with a Python interface for fast code prototyping, directly accessible through Conda.
Pinocchio is now at the heart of various robotics software as Crocoddyl, an open-source and efficient Differential Dynamic Programming solver for robotics, the Stack-of-Tasks, an open-source and versatile hierarchical controller framework or the Humanoid Path Planner, open-source software for Motion and Manipulation Planning.
If you want to learn more about Pinocchio internal behaviors and main features, we invite you to read the related paper and the online documentation.
If you want to dive into Pinocchio directly, only one single line is sufficient (assuming you have Conda):
conda install pinocchio -c conda-forge
or via pip (currently only available on Linux):
pip install pin
Table of contents
- Table of contents
- Introducing Pinocchio 3
- Pinocchio main features
- Documentation
- Examples
- Tutorials
- Pinocchio continuous integrations
- Performances
- Ongoing developments
- Installation
- Visualization
- Citing Pinocchio
- Questions and Issues
- Credits
- Open-source projects relying on Pinocchio
- Acknowledgments
Introducing Pinocchio 3
Pinocchio3 is the latest major release of Pinocchio. It comes with multiple new features, such as:
- Sparse constrained dynamics and its analytical derivatives
- Full support of closed-loop mechanisms
- State-of-the-art frictional contact solvers
- Low-complexity constrained articulated body algorithms
- Full support of multiple-precision floating-point (MPFR) in Python and C++
- Full CasADi support in Python and C++
- Increased support of CppAD and CppADCodeGen
- New SDF and MJCF parsers
- and much more.
Pinocchio main features
Pinocchio is fast:
- C++ template library,
- cache friendly,
- automatic code generation support is available via CppADCodeGen.
Pinocchio is versatile, implementing basic and more advanced rigid body dynamics algorithms:
- forward kinematics and its analytical derivatives,
- forward/inverse dynamics and their analytical derivatives,
- centroidal dynamics and its analytical derivatives,
- support multiple precision arithmetic via Boost.Multiprecision or any similar framework,
- computations of kinematic and dynamic regressors for system identification and more,
- and much more with the support of modern and open-source Automatic Differentiation frameworks like CppAD or CasADi.
Pinocchio is flexible:
- header only,
- C++ 98/03/11/14/17/20 compliant.
Pinocchio is extensible. Pinocchio is multi-thread friendly. Pinocchio is reliable and extensively tested (unit-tests, simulations, and real-world robotics applications). Pinocchio is supported and tested on Windows, Mac OS X, Unix, and Linux (see build status here).
Documentation
The online Pinocchio documentation of the last release is available here. A cheat sheet pdf with the main functions and algorithms can be found here.
Examples
In the examples directory, we provide some basic examples of using Pinocchio in Python. Additional examples introducing Pinocchio are also available in the documentation.
Tutorials
Pinocchio comes with a large bunch of tutorials aiming at introducing the basic tools for robot control. Tutorial and training documents are listed here. You can also consider the interactive Jupyter notebook set of tutorials developed by Nicolas Mansard and Yann de Mont-Marin.
Pinocchio continuous integrations
Pinocchio is constantly tested for several platforms and distributions, as reported below:
CI on ROS | |
CI on Linux via APT | |
CI on OSX via Conda | |
CI on Windows via Conda | |
CI on Linux via Robotpkg |
Performances
Pinocchio exploits, at best, the sparsity induced by the kinematic tree of robotics systems. Thanks to modern programming language paradigms, Pinocchio can unroll most of the computations directly at compile time, allowing to achieve impressive performances for a large range of robots, as illustrated by the plot below, obtained on a standard laptop equipped with an Intel Core i7 CPU @ 2.4 GHz.
For other benchmarks, and mainly the capacity of Pinocchio to exploit, at best, your CPU capacities using advanced code generation techniques, we refer to the technical paper. In addition, the introspection may also help you to understand and compare the performances of the modern rigid body dynamics libraries.
Ongoing developments
If you want to follow the current developments, you can directly refer to the devel branch. The master branch only contains the latest release. Any new Pull Request should then be submitted on the devel branch.
Installation
Pinocchio can be easily installed on various Linux (Ubuntu, Fedora, etc.) and Unix distributions (Mac OS X, BSD, etc.). Please refer to the installation procedure.
If you only need the Python bindings of Pinocchio, you may prefer to install it through Conda. Please follow the procedure described here.
ROS
Pinocchio is also deployed on ROS. You may follow its deployment status below.
If you’re interested in using Pinocchio on systems and/or with packages that integrate with the ROS ecosystem, we recommend the installation of Pinocchio via the binaries distributed via the ROS PPA. Here, you can install Pinocchio using:
sudo apt install ros-$ROS_DISTRO-pinocchio
This installs Pinocchio with HPP-FCL support and with Python bindings. You can then use Pinocchio in your ROS packages by:
- Depending on Pinocchio in your
package.xml
config (<depend>pinocchio</depend>
) - Including Pinocchio via CMake (
find_package(pinocchio REQUIRED)
) and linking against Pinocchio (target_link_libraries(my_library pinocchio::pinocchio)
)
We include support and hooks to discover the package for both ROS 1 and ROS 2. Examples can be found at the following repositories:
Please note that we always advise including the pinocchio/fwd.hpp
header as the first include to avoid compilation errors from differing Boost-variant sizes.
ROS 1 | ROS 2 | |||
---|---|---|---|---|
Melodic | Foxy | |||
Noetic | Galactic | |||
Humble | ||||
Rolling |
Visualization
Pinocchio provides support for many open-source and free visualizers:
- Gepetto Viewer: a C++ viewer based on OpenSceneGraph with Python bindings and Blender export. See here for a C++ example on mixing Pinocchio and Gepetto Viewer.
- Meshcat: supporting visualization in Python and which can be embedded inside any browser.
- Panda3d: supporting visualization in Python and which can be embedded inside any browser.
- RViz: supporting visualization in Python and which can interact with other ROS packages.
Many external viewers can also be integrated. For more information, see the example here.
Citing Pinocchio
To cite Pinocchio in your academic research, please consider citing the software paper and use the following BibTeX entry:
@inproceedings{carpentier2019pinocchio,
title={The Pinocchio C++ library -- A fast and flexible implementation of rigid body dynamics algorithms and their analytical derivatives},
author={Carpentier, Justin and Saurel, Guilhem and Buondonno, Gabriele and Mirabel, Joseph and Lamiraux, Florent and Stasse, Olivier and Mansard, Nicolas},
booktitle={IEEE International Symposium on System Integrations (SII)},
year={2019}
}
And the following one for the link to the GitHub codebase:
@misc{pinocchioweb,
author = {Justin Carpentier and Florian Valenza and Nicolas Mansard and others},
title = {Pinocchio: fast forward and inverse dynamics for poly-articulated systems},
howpublished = {https://stack-of-tasks.github.io/pinocchio},
year = {2015--2021}
}
Citing specific algorithmic contributions
Pinocchio goes beyond implementing the standard rigid-body dynamics algorithms and results from active research on simulation, learning and control. Pinocchio provides state-of-the-art algorithms for handling constraints, differentiating forward and inverse dynamics, etc. If you use these algorithms, please consider citing them in your research articles.
- Le Lidec, Q., Montaut, L. & Carpentier, J. (2024, July). From Compliant to Rigid Contact Simulation: a Unified and Efficient Approach. In RSS 2024-Robotics: Science and Systems.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2024). GJK++: Leveraging Acceleration Methods for Faster Collision Detection. IEEE Transactions on Robotics.
- Sathya, A., & Carpentier, J. (2024). Constrained Articulated Body Dynamics Algorithms. Under review.
- Montaut, L., Le Lidec, Q., Bambade, A., Petrik, V., Sivic, J., & Carpentier, J. (2023, May). Differentiable collision detection: a randomized smoothing approach. In 2023 IEEE International Conference on Robotics and Automation (ICRA).
- Le Lidec, Q., Jallet, W., Montaut, L., Laptev, I., Schmid, C., & Carpentier, J. (2023). Contact models in robotics: a comparative analysis. Under review.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2022, June). Collision Detection Accelerated: An Optimization Perspective. In Robotics: Science and Systems (RSS 2O22).
- Carpentier, J., Budhiraja, R., & Mansard, N. (2021, July). Proximal and sparse resolution of constrained dynamic equations. In Robotics: Science and Systems (RSS 2021).
- Carpentier, J., & Mansard, N. (2018, June). Analytical derivatives of rigid body dynamics algorithms. In Robotics: Science and systems (RSS 2018).
Questions and Issues
Do you have a question or an issue? You may either directly open a new question or a new issue or, directly contact us via the mailing list pinocchio@inria.fr.
Credits
The following people have been involved in the development of Pinocchio and are warmly thanked for their contributions:
- Justin Carpentier (Inria): main developer and manager of the project
- Nicolas Mansard (LAAS-CNRS): initial project instructor
- Guilhem Saurel (LAAS-CNRS): continuous integration and deployment
- Joseph Mirabel (Eureka Robotics): Lie groups and hpp-fcl implementation
- Antonio El Khoury (Wandercraft): bug fixes
- Gabriele Buondono (LAAS-CNRS): features extension, bug fixes, and Python bindings
- Florian Valenza (Astek): core developments and hpp-fcl support
- Wolfgang Merkt (University of Oxford): ROS integration and support
- Rohan Budhiraja (LAAS-CNRS): features extension
- Loïc Estève (Inria): Conda integration and support
- Igor Kalevatykh (Inria): Panda3d viewer support
- Matthieu Vigne (Wandercraft): MeshCat viewer support
- Robin Strudel (Inria): features extension
- François Keith (CEA): Windows support
- Sarah El Kazdadi (Inria): multi-precision arithmetic support
- Nicolas Torres Alberto (Inria): features extension
- Etienne Arlaud (Inria): RViz viewer support
- Wilson Jallet (LAAS-CNRS/Inria): extension of Python bindings
- Fabian Schramm (Inria): core developper
- Shubham Singh (UT Austin): second-order inverse dynamics derivatives
- Stéphane Caron (Inria): core developper
- Joris Vaillant (Inria): core developer and manager of the project
- Sebastian Castro (The AI Institute): MeshCat viewer feature extension
- Lev Kozlov: Kinetic and potential energy regressors
- Megane Millan (Inria): Features extension and core developer
- Simeon Nedelchev: Pseudo inertia and Log-cholesky parametrization
If you have participated in the development of Pinocchio, please add your name and contribution to this list.
Open-source projects relying on Pinocchio
- Crocoddyl: A software to realize model predictive control for complex robotics platforms.
- TSID: A software that implements a Task Space Inverse Dynamics QP.
- HPP: A SDK that implements motion planners for humanoids and other robots.
- Jiminy: A simulator based on Pinocchio.
- ocs2: A toolbox for Optimal Control for Switched Systems (OCS2)
- TriFingerSimulation: TriFinger Robot Simulation (a Robot to perform RL on manipulation).
- Casadi_Kin_Dyn: IIT Package for generation of symbolic (SX) expressions of robot kinematics and dynamics.
- PyRoboPlan: An educational Python library for manipulator motion planning using the Pinocchio Python bindings.
- ProxSuite-NLP: A primal-dual augmented Lagrangian solver for nonlinear programming on manifolds.
- Aligator: A versatile and efficient framework for constrained trajectory optimization.
- Simple: The Simple Simulator: Simulation Made Simple.
- LoIK: Low-Complexity Inverse Kinematics.
Acknowledgments
The development of Pinocchio is actively supported by the Gepetto team @LAAS-CNRS and the Willow team @INRIA.
CONTRIBUTING
Contributing Guidelines
Thank you for your interest in contributing to pinocchio
.
Whether it’s a bug report, new feature, correction, or additional
documentation, we greatly value feedback and contributions from our community.
Please read through this document before submitting any issues or pull requests to ensure we have all the necessary information to effectively respond to your bug report or contribution.
Reporting Bugs/Feature Requests
We welcome you to use the GitHub issue tracker to report bugs or suggest features.
When filing an issue, please check [existing open][issues], or [recently closed][closed-issues], issues to make sure somebody else hasn’t already reported the issue. Please try to include as much information as you can. Details like these are incredibly useful:
- A reproducible test case or series of steps
- The version of our code being used
- Any modifications you’ve made relevant to the bug
- Anything unusual about your environment or deployment
Contributing via Pull Requests
The following guidance should be up-to-date, but the documentation as found here should prove as the final say.
Contributions via pull requests are much appreciated. Before sending us a pull request, please ensure that:
- Limited scope. Your PR should do one thing or one set of things. Avoid adding “random fixes” to PRs. Put those on separate PRs.
- Give your PR a descriptive title. Add a short summary, if required.
- Make sure the pipeline is green.
- Don’t be afraid to request reviews from maintainers.
- New code = new tests. If you are adding new functionality, always make sure to add some tests exercising the code and serving as live documentation of your original intention.
To send us a pull request, please:
- Fork the repository.
- Modify the source; please focus on the specific change you are contributing. If you also reformat all the code, it will be hard for us to focus on your change.
- Ensure local tests pass. (
make test
) - Commit to your fork using clear commit messages.
- Send a pull request, answering any default questions in the pull request interface.
- Pay attention to any automated CI failures reported in the pull request, and stay involved in the conversation.
GitHub provides additional documentation on forking a repository and creating a pull request.
Finding contributions to work on
Looking at the existing issues is a great way to find something to contribute on. As this project, by default, uses the default GitHub issue labels (enhancement/bug/duplicate/help wanted/invalid/question/wontfix), looking at any [‘help wanted’][help-wanted] issues is a great place to start.
Licensing
Any contribution that you make to this repository will be under the BSD Clause 2 License, as dictated by that [license]:
BSD 2-Clause License
Copyright (c) 2014-2021, CNRS
Copyright (c) 2018-2021, INRIA
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the Pinocchio project.
Repository Summary
Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
VCS Type | git |
VCS Version | devel |
Last Updated | 2024-10-14 |
Dev Status | DEVELOPED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
Name | Version |
---|---|
pinocchio | 3.2.0 |
README
Pinocchio instantiates the state-of-the-art Rigid Body Algorithms for poly-articulated systems based on revisited Roy Featherstone’s algorithms. Besides, Pinocchio provides the analytical derivatives of the main Rigid-Body Algorithms, such as the Recursive Newton-Euler Algorithm or the Articulated-Body Algorithm.
Pinocchio was first tailored for robotics applications, but it can be used in other contexts (biomechanics, computer graphics, vision, etc.). It is built upon Eigen for linear algebra and FCL for collision detection. Pinocchio comes with a Python interface for fast code prototyping, directly accessible through Conda.
Pinocchio is now at the heart of various robotics software as Crocoddyl, an open-source and efficient Differential Dynamic Programming solver for robotics, the Stack-of-Tasks, an open-source and versatile hierarchical controller framework or the Humanoid Path Planner, open-source software for Motion and Manipulation Planning.
If you want to learn more about Pinocchio internal behaviors and main features, we invite you to read the related paper and the online documentation.
If you want to dive into Pinocchio directly, only one single line is sufficient (assuming you have Conda):
conda install pinocchio -c conda-forge
or via pip (currently only available on Linux):
pip install pin
Table of contents
- Table of contents
- Introducing Pinocchio 3
- Pinocchio main features
- Documentation
- Examples
- Tutorials
- Pinocchio continuous integrations
- Performances
- Ongoing developments
- Installation
- Visualization
- Citing Pinocchio
- Questions and Issues
- Credits
- Open-source projects relying on Pinocchio
- Acknowledgments
Introducing Pinocchio 3
Pinocchio3 is the latest major release of Pinocchio. It comes with multiple new features, such as:
- Sparse constrained dynamics and its analytical derivatives
- Full support of closed-loop mechanisms
- State-of-the-art frictional contact solvers
- Low-complexity constrained articulated body algorithms
- Full support of multiple-precision floating-point (MPFR) in Python and C++
- Full CasADi support in Python and C++
- Increased support of CppAD and CppADCodeGen
- New SDF and MJCF parsers
- and much more.
Pinocchio main features
Pinocchio is fast:
- C++ template library,
- cache friendly,
- automatic code generation support is available via CppADCodeGen.
Pinocchio is versatile, implementing basic and more advanced rigid body dynamics algorithms:
- forward kinematics and its analytical derivatives,
- forward/inverse dynamics and their analytical derivatives,
- centroidal dynamics and its analytical derivatives,
- support multiple precision arithmetic via Boost.Multiprecision or any similar framework,
- computations of kinematic and dynamic regressors for system identification and more,
- and much more with the support of modern and open-source Automatic Differentiation frameworks like CppAD or CasADi.
Pinocchio is flexible:
- header only,
- C++ 98/03/11/14/17/20 compliant.
Pinocchio is extensible. Pinocchio is multi-thread friendly. Pinocchio is reliable and extensively tested (unit-tests, simulations, and real-world robotics applications). Pinocchio is supported and tested on Windows, Mac OS X, Unix, and Linux (see build status here).
Documentation
The online Pinocchio documentation of the last release is available here. A cheat sheet pdf with the main functions and algorithms can be found here.
Examples
In the examples directory, we provide some basic examples of using Pinocchio in Python. Additional examples introducing Pinocchio are also available in the documentation.
Tutorials
Pinocchio comes with a large bunch of tutorials aiming at introducing the basic tools for robot control. Tutorial and training documents are listed here. You can also consider the interactive Jupyter notebook set of tutorials developed by Nicolas Mansard and Yann de Mont-Marin.
Pinocchio continuous integrations
Pinocchio is constantly tested for several platforms and distributions, as reported below:
CI on ROS | |
CI on Linux via APT | |
CI on OSX via Conda | |
CI on Windows via Conda | |
CI on Linux via Robotpkg |
Performances
Pinocchio exploits, at best, the sparsity induced by the kinematic tree of robotics systems. Thanks to modern programming language paradigms, Pinocchio can unroll most of the computations directly at compile time, allowing to achieve impressive performances for a large range of robots, as illustrated by the plot below, obtained on a standard laptop equipped with an Intel Core i7 CPU @ 2.4 GHz.
For other benchmarks, and mainly the capacity of Pinocchio to exploit, at best, your CPU capacities using advanced code generation techniques, we refer to the technical paper. In addition, the introspection may also help you to understand and compare the performances of the modern rigid body dynamics libraries.
Ongoing developments
If you want to follow the current developments, you can directly refer to the devel branch. The master branch only contains the latest release. Any new Pull Request should then be submitted on the devel branch.
Installation
Pinocchio can be easily installed on various Linux (Ubuntu, Fedora, etc.) and Unix distributions (Mac OS X, BSD, etc.). Please refer to the installation procedure.
If you only need the Python bindings of Pinocchio, you may prefer to install it through Conda. Please follow the procedure described here.
ROS
Pinocchio is also deployed on ROS. You may follow its deployment status below.
If you’re interested in using Pinocchio on systems and/or with packages that integrate with the ROS ecosystem, we recommend the installation of Pinocchio via the binaries distributed via the ROS PPA. Here, you can install Pinocchio using:
sudo apt install ros-$ROS_DISTRO-pinocchio
This installs Pinocchio with HPP-FCL support and with Python bindings. You can then use Pinocchio in your ROS packages by:
- Depending on Pinocchio in your
package.xml
config (<depend>pinocchio</depend>
) - Including Pinocchio via CMake (
find_package(pinocchio REQUIRED)
) and linking against Pinocchio (target_link_libraries(my_library pinocchio::pinocchio)
)
We include support and hooks to discover the package for both ROS 1 and ROS 2. Examples can be found at the following repositories:
Please note that we always advise including the pinocchio/fwd.hpp
header as the first include to avoid compilation errors from differing Boost-variant sizes.
ROS 1 | ROS 2 | |||
---|---|---|---|---|
Melodic | Foxy | |||
Noetic | Galactic | |||
Humble | ||||
Rolling |
Visualization
Pinocchio provides support for many open-source and free visualizers:
- Gepetto Viewer: a C++ viewer based on OpenSceneGraph with Python bindings and Blender export. See here for a C++ example on mixing Pinocchio and Gepetto Viewer.
- Meshcat: supporting visualization in Python and which can be embedded inside any browser.
- Panda3d: supporting visualization in Python and which can be embedded inside any browser.
- RViz: supporting visualization in Python and which can interact with other ROS packages.
Many external viewers can also be integrated. For more information, see the example here.
Citing Pinocchio
To cite Pinocchio in your academic research, please consider citing the software paper and use the following BibTeX entry:
@inproceedings{carpentier2019pinocchio,
title={The Pinocchio C++ library -- A fast and flexible implementation of rigid body dynamics algorithms and their analytical derivatives},
author={Carpentier, Justin and Saurel, Guilhem and Buondonno, Gabriele and Mirabel, Joseph and Lamiraux, Florent and Stasse, Olivier and Mansard, Nicolas},
booktitle={IEEE International Symposium on System Integrations (SII)},
year={2019}
}
And the following one for the link to the GitHub codebase:
@misc{pinocchioweb,
author = {Justin Carpentier and Florian Valenza and Nicolas Mansard and others},
title = {Pinocchio: fast forward and inverse dynamics for poly-articulated systems},
howpublished = {https://stack-of-tasks.github.io/pinocchio},
year = {2015--2021}
}
Citing specific algorithmic contributions
Pinocchio goes beyond implementing the standard rigid-body dynamics algorithms and results from active research on simulation, learning and control. Pinocchio provides state-of-the-art algorithms for handling constraints, differentiating forward and inverse dynamics, etc. If you use these algorithms, please consider citing them in your research articles.
- Le Lidec, Q., Montaut, L. & Carpentier, J. (2024, July). From Compliant to Rigid Contact Simulation: a Unified and Efficient Approach. In RSS 2024-Robotics: Science and Systems.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2024). GJK++: Leveraging Acceleration Methods for Faster Collision Detection. IEEE Transactions on Robotics.
- Sathya, A., & Carpentier, J. (2024). Constrained Articulated Body Dynamics Algorithms. Under review.
- Montaut, L., Le Lidec, Q., Bambade, A., Petrik, V., Sivic, J., & Carpentier, J. (2023, May). Differentiable collision detection: a randomized smoothing approach. In 2023 IEEE International Conference on Robotics and Automation (ICRA).
- Le Lidec, Q., Jallet, W., Montaut, L., Laptev, I., Schmid, C., & Carpentier, J. (2023). Contact models in robotics: a comparative analysis. Under review.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2022, June). Collision Detection Accelerated: An Optimization Perspective. In Robotics: Science and Systems (RSS 2O22).
- Carpentier, J., Budhiraja, R., & Mansard, N. (2021, July). Proximal and sparse resolution of constrained dynamic equations. In Robotics: Science and Systems (RSS 2021).
- Carpentier, J., & Mansard, N. (2018, June). Analytical derivatives of rigid body dynamics algorithms. In Robotics: Science and systems (RSS 2018).
Questions and Issues
Do you have a question or an issue? You may either directly open a new question or a new issue or, directly contact us via the mailing list pinocchio@inria.fr.
Credits
The following people have been involved in the development of Pinocchio and are warmly thanked for their contributions:
- Justin Carpentier (Inria): main developer and manager of the project
- Nicolas Mansard (LAAS-CNRS): initial project instructor
- Guilhem Saurel (LAAS-CNRS): continuous integration and deployment
- Joseph Mirabel (Eureka Robotics): Lie groups and hpp-fcl implementation
- Antonio El Khoury (Wandercraft): bug fixes
- Gabriele Buondono (LAAS-CNRS): features extension, bug fixes, and Python bindings
- Florian Valenza (Astek): core developments and hpp-fcl support
- Wolfgang Merkt (University of Oxford): ROS integration and support
- Rohan Budhiraja (LAAS-CNRS): features extension
- Loïc Estève (Inria): Conda integration and support
- Igor Kalevatykh (Inria): Panda3d viewer support
- Matthieu Vigne (Wandercraft): MeshCat viewer support
- Robin Strudel (Inria): features extension
- François Keith (CEA): Windows support
- Sarah El Kazdadi (Inria): multi-precision arithmetic support
- Nicolas Torres Alberto (Inria): features extension
- Etienne Arlaud (Inria): RViz viewer support
- Wilson Jallet (LAAS-CNRS/Inria): extension of Python bindings
- Fabian Schramm (Inria): core developper
- Shubham Singh (UT Austin): second-order inverse dynamics derivatives
- Stéphane Caron (Inria): core developper
- Joris Vaillant (Inria): core developer and manager of the project
- Sebastian Castro (The AI Institute): MeshCat viewer feature extension
- Lev Kozlov: Kinetic and potential energy regressors
- Megane Millan (Inria): Features extension and core developer
- Simeon Nedelchev: Pseudo inertia and Log-cholesky parametrization
If you have participated in the development of Pinocchio, please add your name and contribution to this list.
Open-source projects relying on Pinocchio
- Crocoddyl: A software to realize model predictive control for complex robotics platforms.
- TSID: A software that implements a Task Space Inverse Dynamics QP.
- HPP: A SDK that implements motion planners for humanoids and other robots.
- Jiminy: A simulator based on Pinocchio.
- ocs2: A toolbox for Optimal Control for Switched Systems (OCS2)
- TriFingerSimulation: TriFinger Robot Simulation (a Robot to perform RL on manipulation).
- Casadi_Kin_Dyn: IIT Package for generation of symbolic (SX) expressions of robot kinematics and dynamics.
- PyRoboPlan: An educational Python library for manipulator motion planning using the Pinocchio Python bindings.
- ProxSuite-NLP: A primal-dual augmented Lagrangian solver for nonlinear programming on manifolds.
- Aligator: A versatile and efficient framework for constrained trajectory optimization.
- Simple: The Simple Simulator: Simulation Made Simple.
- LoIK: Low-Complexity Inverse Kinematics.
Acknowledgments
The development of Pinocchio is actively supported by the Gepetto team @LAAS-CNRS and the Willow team @INRIA.
CONTRIBUTING
Contributing Guidelines
Thank you for your interest in contributing to pinocchio
.
Whether it’s a bug report, new feature, correction, or additional
documentation, we greatly value feedback and contributions from our community.
Please read through this document before submitting any issues or pull requests to ensure we have all the necessary information to effectively respond to your bug report or contribution.
Reporting Bugs/Feature Requests
We welcome you to use the GitHub issue tracker to report bugs or suggest features.
When filing an issue, please check [existing open][issues], or [recently closed][closed-issues], issues to make sure somebody else hasn’t already reported the issue. Please try to include as much information as you can. Details like these are incredibly useful:
- A reproducible test case or series of steps
- The version of our code being used
- Any modifications you’ve made relevant to the bug
- Anything unusual about your environment or deployment
Contributing via Pull Requests
The following guidance should be up-to-date, but the documentation as found here should prove as the final say.
Contributions via pull requests are much appreciated. Before sending us a pull request, please ensure that:
- Limited scope. Your PR should do one thing or one set of things. Avoid adding “random fixes” to PRs. Put those on separate PRs.
- Give your PR a descriptive title. Add a short summary, if required.
- Make sure the pipeline is green.
- Don’t be afraid to request reviews from maintainers.
- New code = new tests. If you are adding new functionality, always make sure to add some tests exercising the code and serving as live documentation of your original intention.
To send us a pull request, please:
- Fork the repository.
- Modify the source; please focus on the specific change you are contributing. If you also reformat all the code, it will be hard for us to focus on your change.
- Ensure local tests pass. (
make test
) - Commit to your fork using clear commit messages.
- Send a pull request, answering any default questions in the pull request interface.
- Pay attention to any automated CI failures reported in the pull request, and stay involved in the conversation.
GitHub provides additional documentation on forking a repository and creating a pull request.
Finding contributions to work on
Looking at the existing issues is a great way to find something to contribute on. As this project, by default, uses the default GitHub issue labels (enhancement/bug/duplicate/help wanted/invalid/question/wontfix), looking at any [‘help wanted’][help-wanted] issues is a great place to start.
Licensing
Any contribution that you make to this repository will be under the BSD Clause 2 License, as dictated by that [license]:
BSD 2-Clause License
Copyright (c) 2014-2021, CNRS
Copyright (c) 2018-2021, INRIA
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the Pinocchio project.
Repository Summary
Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
VCS Type | git |
VCS Version | devel |
Last Updated | 2024-10-14 |
Dev Status | DEVELOPED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
Name | Version |
---|---|
pinocchio | 3.2.0 |
README
Pinocchio instantiates the state-of-the-art Rigid Body Algorithms for poly-articulated systems based on revisited Roy Featherstone’s algorithms. Besides, Pinocchio provides the analytical derivatives of the main Rigid-Body Algorithms, such as the Recursive Newton-Euler Algorithm or the Articulated-Body Algorithm.
Pinocchio was first tailored for robotics applications, but it can be used in other contexts (biomechanics, computer graphics, vision, etc.). It is built upon Eigen for linear algebra and FCL for collision detection. Pinocchio comes with a Python interface for fast code prototyping, directly accessible through Conda.
Pinocchio is now at the heart of various robotics software as Crocoddyl, an open-source and efficient Differential Dynamic Programming solver for robotics, the Stack-of-Tasks, an open-source and versatile hierarchical controller framework or the Humanoid Path Planner, open-source software for Motion and Manipulation Planning.
If you want to learn more about Pinocchio internal behaviors and main features, we invite you to read the related paper and the online documentation.
If you want to dive into Pinocchio directly, only one single line is sufficient (assuming you have Conda):
conda install pinocchio -c conda-forge
or via pip (currently only available on Linux):
pip install pin
Table of contents
- Table of contents
- Introducing Pinocchio 3
- Pinocchio main features
- Documentation
- Examples
- Tutorials
- Pinocchio continuous integrations
- Performances
- Ongoing developments
- Installation
- Visualization
- Citing Pinocchio
- Questions and Issues
- Credits
- Open-source projects relying on Pinocchio
- Acknowledgments
Introducing Pinocchio 3
Pinocchio3 is the latest major release of Pinocchio. It comes with multiple new features, such as:
- Sparse constrained dynamics and its analytical derivatives
- Full support of closed-loop mechanisms
- State-of-the-art frictional contact solvers
- Low-complexity constrained articulated body algorithms
- Full support of multiple-precision floating-point (MPFR) in Python and C++
- Full CasADi support in Python and C++
- Increased support of CppAD and CppADCodeGen
- New SDF and MJCF parsers
- and much more.
Pinocchio main features
Pinocchio is fast:
- C++ template library,
- cache friendly,
- automatic code generation support is available via CppADCodeGen.
Pinocchio is versatile, implementing basic and more advanced rigid body dynamics algorithms:
- forward kinematics and its analytical derivatives,
- forward/inverse dynamics and their analytical derivatives,
- centroidal dynamics and its analytical derivatives,
- support multiple precision arithmetic via Boost.Multiprecision or any similar framework,
- computations of kinematic and dynamic regressors for system identification and more,
- and much more with the support of modern and open-source Automatic Differentiation frameworks like CppAD or CasADi.
Pinocchio is flexible:
- header only,
- C++ 98/03/11/14/17/20 compliant.
Pinocchio is extensible. Pinocchio is multi-thread friendly. Pinocchio is reliable and extensively tested (unit-tests, simulations, and real-world robotics applications). Pinocchio is supported and tested on Windows, Mac OS X, Unix, and Linux (see build status here).
Documentation
The online Pinocchio documentation of the last release is available here. A cheat sheet pdf with the main functions and algorithms can be found here.
Examples
In the examples directory, we provide some basic examples of using Pinocchio in Python. Additional examples introducing Pinocchio are also available in the documentation.
Tutorials
Pinocchio comes with a large bunch of tutorials aiming at introducing the basic tools for robot control. Tutorial and training documents are listed here. You can also consider the interactive Jupyter notebook set of tutorials developed by Nicolas Mansard and Yann de Mont-Marin.
Pinocchio continuous integrations
Pinocchio is constantly tested for several platforms and distributions, as reported below:
CI on ROS | |
CI on Linux via APT | |
CI on OSX via Conda | |
CI on Windows via Conda | |
CI on Linux via Robotpkg |
Performances
Pinocchio exploits, at best, the sparsity induced by the kinematic tree of robotics systems. Thanks to modern programming language paradigms, Pinocchio can unroll most of the computations directly at compile time, allowing to achieve impressive performances for a large range of robots, as illustrated by the plot below, obtained on a standard laptop equipped with an Intel Core i7 CPU @ 2.4 GHz.
For other benchmarks, and mainly the capacity of Pinocchio to exploit, at best, your CPU capacities using advanced code generation techniques, we refer to the technical paper. In addition, the introspection may also help you to understand and compare the performances of the modern rigid body dynamics libraries.
Ongoing developments
If you want to follow the current developments, you can directly refer to the devel branch. The master branch only contains the latest release. Any new Pull Request should then be submitted on the devel branch.
Installation
Pinocchio can be easily installed on various Linux (Ubuntu, Fedora, etc.) and Unix distributions (Mac OS X, BSD, etc.). Please refer to the installation procedure.
If you only need the Python bindings of Pinocchio, you may prefer to install it through Conda. Please follow the procedure described here.
ROS
Pinocchio is also deployed on ROS. You may follow its deployment status below.
If you’re interested in using Pinocchio on systems and/or with packages that integrate with the ROS ecosystem, we recommend the installation of Pinocchio via the binaries distributed via the ROS PPA. Here, you can install Pinocchio using:
sudo apt install ros-$ROS_DISTRO-pinocchio
This installs Pinocchio with HPP-FCL support and with Python bindings. You can then use Pinocchio in your ROS packages by:
- Depending on Pinocchio in your
package.xml
config (<depend>pinocchio</depend>
) - Including Pinocchio via CMake (
find_package(pinocchio REQUIRED)
) and linking against Pinocchio (target_link_libraries(my_library pinocchio::pinocchio)
)
We include support and hooks to discover the package for both ROS 1 and ROS 2. Examples can be found at the following repositories:
Please note that we always advise including the pinocchio/fwd.hpp
header as the first include to avoid compilation errors from differing Boost-variant sizes.
ROS 1 | ROS 2 | |||
---|---|---|---|---|
Melodic | Foxy | |||
Noetic | Galactic | |||
Humble | ||||
Rolling |
Visualization
Pinocchio provides support for many open-source and free visualizers:
- Gepetto Viewer: a C++ viewer based on OpenSceneGraph with Python bindings and Blender export. See here for a C++ example on mixing Pinocchio and Gepetto Viewer.
- Meshcat: supporting visualization in Python and which can be embedded inside any browser.
- Panda3d: supporting visualization in Python and which can be embedded inside any browser.
- RViz: supporting visualization in Python and which can interact with other ROS packages.
Many external viewers can also be integrated. For more information, see the example here.
Citing Pinocchio
To cite Pinocchio in your academic research, please consider citing the software paper and use the following BibTeX entry:
@inproceedings{carpentier2019pinocchio,
title={The Pinocchio C++ library -- A fast and flexible implementation of rigid body dynamics algorithms and their analytical derivatives},
author={Carpentier, Justin and Saurel, Guilhem and Buondonno, Gabriele and Mirabel, Joseph and Lamiraux, Florent and Stasse, Olivier and Mansard, Nicolas},
booktitle={IEEE International Symposium on System Integrations (SII)},
year={2019}
}
And the following one for the link to the GitHub codebase:
@misc{pinocchioweb,
author = {Justin Carpentier and Florian Valenza and Nicolas Mansard and others},
title = {Pinocchio: fast forward and inverse dynamics for poly-articulated systems},
howpublished = {https://stack-of-tasks.github.io/pinocchio},
year = {2015--2021}
}
Citing specific algorithmic contributions
Pinocchio goes beyond implementing the standard rigid-body dynamics algorithms and results from active research on simulation, learning and control. Pinocchio provides state-of-the-art algorithms for handling constraints, differentiating forward and inverse dynamics, etc. If you use these algorithms, please consider citing them in your research articles.
- Le Lidec, Q., Montaut, L. & Carpentier, J. (2024, July). From Compliant to Rigid Contact Simulation: a Unified and Efficient Approach. In RSS 2024-Robotics: Science and Systems.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2024). GJK++: Leveraging Acceleration Methods for Faster Collision Detection. IEEE Transactions on Robotics.
- Sathya, A., & Carpentier, J. (2024). Constrained Articulated Body Dynamics Algorithms. Under review.
- Montaut, L., Le Lidec, Q., Bambade, A., Petrik, V., Sivic, J., & Carpentier, J. (2023, May). Differentiable collision detection: a randomized smoothing approach. In 2023 IEEE International Conference on Robotics and Automation (ICRA).
- Le Lidec, Q., Jallet, W., Montaut, L., Laptev, I., Schmid, C., & Carpentier, J. (2023). Contact models in robotics: a comparative analysis. Under review.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2022, June). Collision Detection Accelerated: An Optimization Perspective. In Robotics: Science and Systems (RSS 2O22).
- Carpentier, J., Budhiraja, R., & Mansard, N. (2021, July). Proximal and sparse resolution of constrained dynamic equations. In Robotics: Science and Systems (RSS 2021).
- Carpentier, J., & Mansard, N. (2018, June). Analytical derivatives of rigid body dynamics algorithms. In Robotics: Science and systems (RSS 2018).
Questions and Issues
Do you have a question or an issue? You may either directly open a new question or a new issue or, directly contact us via the mailing list pinocchio@inria.fr.
Credits
The following people have been involved in the development of Pinocchio and are warmly thanked for their contributions:
- Justin Carpentier (Inria): main developer and manager of the project
- Nicolas Mansard (LAAS-CNRS): initial project instructor
- Guilhem Saurel (LAAS-CNRS): continuous integration and deployment
- Joseph Mirabel (Eureka Robotics): Lie groups and hpp-fcl implementation
- Antonio El Khoury (Wandercraft): bug fixes
- Gabriele Buondono (LAAS-CNRS): features extension, bug fixes, and Python bindings
- Florian Valenza (Astek): core developments and hpp-fcl support
- Wolfgang Merkt (University of Oxford): ROS integration and support
- Rohan Budhiraja (LAAS-CNRS): features extension
- Loïc Estève (Inria): Conda integration and support
- Igor Kalevatykh (Inria): Panda3d viewer support
- Matthieu Vigne (Wandercraft): MeshCat viewer support
- Robin Strudel (Inria): features extension
- François Keith (CEA): Windows support
- Sarah El Kazdadi (Inria): multi-precision arithmetic support
- Nicolas Torres Alberto (Inria): features extension
- Etienne Arlaud (Inria): RViz viewer support
- Wilson Jallet (LAAS-CNRS/Inria): extension of Python bindings
- Fabian Schramm (Inria): core developper
- Shubham Singh (UT Austin): second-order inverse dynamics derivatives
- Stéphane Caron (Inria): core developper
- Joris Vaillant (Inria): core developer and manager of the project
- Sebastian Castro (The AI Institute): MeshCat viewer feature extension
- Lev Kozlov: Kinetic and potential energy regressors
- Megane Millan (Inria): Features extension and core developer
- Simeon Nedelchev: Pseudo inertia and Log-cholesky parametrization
If you have participated in the development of Pinocchio, please add your name and contribution to this list.
Open-source projects relying on Pinocchio
- Crocoddyl: A software to realize model predictive control for complex robotics platforms.
- TSID: A software that implements a Task Space Inverse Dynamics QP.
- HPP: A SDK that implements motion planners for humanoids and other robots.
- Jiminy: A simulator based on Pinocchio.
- ocs2: A toolbox for Optimal Control for Switched Systems (OCS2)
- TriFingerSimulation: TriFinger Robot Simulation (a Robot to perform RL on manipulation).
- Casadi_Kin_Dyn: IIT Package for generation of symbolic (SX) expressions of robot kinematics and dynamics.
- PyRoboPlan: An educational Python library for manipulator motion planning using the Pinocchio Python bindings.
- ProxSuite-NLP: A primal-dual augmented Lagrangian solver for nonlinear programming on manifolds.
- Aligator: A versatile and efficient framework for constrained trajectory optimization.
- Simple: The Simple Simulator: Simulation Made Simple.
- LoIK: Low-Complexity Inverse Kinematics.
Acknowledgments
The development of Pinocchio is actively supported by the Gepetto team @LAAS-CNRS and the Willow team @INRIA.
CONTRIBUTING
Contributing Guidelines
Thank you for your interest in contributing to pinocchio
.
Whether it’s a bug report, new feature, correction, or additional
documentation, we greatly value feedback and contributions from our community.
Please read through this document before submitting any issues or pull requests to ensure we have all the necessary information to effectively respond to your bug report or contribution.
Reporting Bugs/Feature Requests
We welcome you to use the GitHub issue tracker to report bugs or suggest features.
When filing an issue, please check [existing open][issues], or [recently closed][closed-issues], issues to make sure somebody else hasn’t already reported the issue. Please try to include as much information as you can. Details like these are incredibly useful:
- A reproducible test case or series of steps
- The version of our code being used
- Any modifications you’ve made relevant to the bug
- Anything unusual about your environment or deployment
Contributing via Pull Requests
The following guidance should be up-to-date, but the documentation as found here should prove as the final say.
Contributions via pull requests are much appreciated. Before sending us a pull request, please ensure that:
- Limited scope. Your PR should do one thing or one set of things. Avoid adding “random fixes” to PRs. Put those on separate PRs.
- Give your PR a descriptive title. Add a short summary, if required.
- Make sure the pipeline is green.
- Don’t be afraid to request reviews from maintainers.
- New code = new tests. If you are adding new functionality, always make sure to add some tests exercising the code and serving as live documentation of your original intention.
To send us a pull request, please:
- Fork the repository.
- Modify the source; please focus on the specific change you are contributing. If you also reformat all the code, it will be hard for us to focus on your change.
- Ensure local tests pass. (
make test
) - Commit to your fork using clear commit messages.
- Send a pull request, answering any default questions in the pull request interface.
- Pay attention to any automated CI failures reported in the pull request, and stay involved in the conversation.
GitHub provides additional documentation on forking a repository and creating a pull request.
Finding contributions to work on
Looking at the existing issues is a great way to find something to contribute on. As this project, by default, uses the default GitHub issue labels (enhancement/bug/duplicate/help wanted/invalid/question/wontfix), looking at any [‘help wanted’][help-wanted] issues is a great place to start.
Licensing
Any contribution that you make to this repository will be under the BSD Clause 2 License, as dictated by that [license]:
BSD 2-Clause License
Copyright (c) 2014-2021, CNRS
Copyright (c) 2018-2021, INRIA
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the Pinocchio project.
Repository Summary
Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
VCS Type | git |
VCS Version | devel |
Last Updated | 2024-10-14 |
Dev Status | DEVELOPED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
Name | Version |
---|---|
pinocchio | 3.2.0 |
README
Pinocchio instantiates the state-of-the-art Rigid Body Algorithms for poly-articulated systems based on revisited Roy Featherstone’s algorithms. Besides, Pinocchio provides the analytical derivatives of the main Rigid-Body Algorithms, such as the Recursive Newton-Euler Algorithm or the Articulated-Body Algorithm.
Pinocchio was first tailored for robotics applications, but it can be used in other contexts (biomechanics, computer graphics, vision, etc.). It is built upon Eigen for linear algebra and FCL for collision detection. Pinocchio comes with a Python interface for fast code prototyping, directly accessible through Conda.
Pinocchio is now at the heart of various robotics software as Crocoddyl, an open-source and efficient Differential Dynamic Programming solver for robotics, the Stack-of-Tasks, an open-source and versatile hierarchical controller framework or the Humanoid Path Planner, open-source software for Motion and Manipulation Planning.
If you want to learn more about Pinocchio internal behaviors and main features, we invite you to read the related paper and the online documentation.
If you want to dive into Pinocchio directly, only one single line is sufficient (assuming you have Conda):
conda install pinocchio -c conda-forge
or via pip (currently only available on Linux):
pip install pin
Table of contents
- Table of contents
- Introducing Pinocchio 3
- Pinocchio main features
- Documentation
- Examples
- Tutorials
- Pinocchio continuous integrations
- Performances
- Ongoing developments
- Installation
- Visualization
- Citing Pinocchio
- Questions and Issues
- Credits
- Open-source projects relying on Pinocchio
- Acknowledgments
Introducing Pinocchio 3
Pinocchio3 is the latest major release of Pinocchio. It comes with multiple new features, such as:
- Sparse constrained dynamics and its analytical derivatives
- Full support of closed-loop mechanisms
- State-of-the-art frictional contact solvers
- Low-complexity constrained articulated body algorithms
- Full support of multiple-precision floating-point (MPFR) in Python and C++
- Full CasADi support in Python and C++
- Increased support of CppAD and CppADCodeGen
- New SDF and MJCF parsers
- and much more.
Pinocchio main features
Pinocchio is fast:
- C++ template library,
- cache friendly,
- automatic code generation support is available via CppADCodeGen.
Pinocchio is versatile, implementing basic and more advanced rigid body dynamics algorithms:
- forward kinematics and its analytical derivatives,
- forward/inverse dynamics and their analytical derivatives,
- centroidal dynamics and its analytical derivatives,
- support multiple precision arithmetic via Boost.Multiprecision or any similar framework,
- computations of kinematic and dynamic regressors for system identification and more,
- and much more with the support of modern and open-source Automatic Differentiation frameworks like CppAD or CasADi.
Pinocchio is flexible:
- header only,
- C++ 98/03/11/14/17/20 compliant.
Pinocchio is extensible. Pinocchio is multi-thread friendly. Pinocchio is reliable and extensively tested (unit-tests, simulations, and real-world robotics applications). Pinocchio is supported and tested on Windows, Mac OS X, Unix, and Linux (see build status here).
Documentation
The online Pinocchio documentation of the last release is available here. A cheat sheet pdf with the main functions and algorithms can be found here.
Examples
In the examples directory, we provide some basic examples of using Pinocchio in Python. Additional examples introducing Pinocchio are also available in the documentation.
Tutorials
Pinocchio comes with a large bunch of tutorials aiming at introducing the basic tools for robot control. Tutorial and training documents are listed here. You can also consider the interactive Jupyter notebook set of tutorials developed by Nicolas Mansard and Yann de Mont-Marin.
Pinocchio continuous integrations
Pinocchio is constantly tested for several platforms and distributions, as reported below:
CI on ROS | |
CI on Linux via APT | |
CI on OSX via Conda | |
CI on Windows via Conda | |
CI on Linux via Robotpkg |
Performances
Pinocchio exploits, at best, the sparsity induced by the kinematic tree of robotics systems. Thanks to modern programming language paradigms, Pinocchio can unroll most of the computations directly at compile time, allowing to achieve impressive performances for a large range of robots, as illustrated by the plot below, obtained on a standard laptop equipped with an Intel Core i7 CPU @ 2.4 GHz.
For other benchmarks, and mainly the capacity of Pinocchio to exploit, at best, your CPU capacities using advanced code generation techniques, we refer to the technical paper. In addition, the introspection may also help you to understand and compare the performances of the modern rigid body dynamics libraries.
Ongoing developments
If you want to follow the current developments, you can directly refer to the devel branch. The master branch only contains the latest release. Any new Pull Request should then be submitted on the devel branch.
Installation
Pinocchio can be easily installed on various Linux (Ubuntu, Fedora, etc.) and Unix distributions (Mac OS X, BSD, etc.). Please refer to the installation procedure.
If you only need the Python bindings of Pinocchio, you may prefer to install it through Conda. Please follow the procedure described here.
ROS
Pinocchio is also deployed on ROS. You may follow its deployment status below.
If you’re interested in using Pinocchio on systems and/or with packages that integrate with the ROS ecosystem, we recommend the installation of Pinocchio via the binaries distributed via the ROS PPA. Here, you can install Pinocchio using:
sudo apt install ros-$ROS_DISTRO-pinocchio
This installs Pinocchio with HPP-FCL support and with Python bindings. You can then use Pinocchio in your ROS packages by:
- Depending on Pinocchio in your
package.xml
config (<depend>pinocchio</depend>
) - Including Pinocchio via CMake (
find_package(pinocchio REQUIRED)
) and linking against Pinocchio (target_link_libraries(my_library pinocchio::pinocchio)
)
We include support and hooks to discover the package for both ROS 1 and ROS 2. Examples can be found at the following repositories:
Please note that we always advise including the pinocchio/fwd.hpp
header as the first include to avoid compilation errors from differing Boost-variant sizes.
ROS 1 | ROS 2 | |||
---|---|---|---|---|
Melodic | Foxy | |||
Noetic | Galactic | |||
Humble | ||||
Rolling |
Visualization
Pinocchio provides support for many open-source and free visualizers:
- Gepetto Viewer: a C++ viewer based on OpenSceneGraph with Python bindings and Blender export. See here for a C++ example on mixing Pinocchio and Gepetto Viewer.
- Meshcat: supporting visualization in Python and which can be embedded inside any browser.
- Panda3d: supporting visualization in Python and which can be embedded inside any browser.
- RViz: supporting visualization in Python and which can interact with other ROS packages.
Many external viewers can also be integrated. For more information, see the example here.
Citing Pinocchio
To cite Pinocchio in your academic research, please consider citing the software paper and use the following BibTeX entry:
@inproceedings{carpentier2019pinocchio,
title={The Pinocchio C++ library -- A fast and flexible implementation of rigid body dynamics algorithms and their analytical derivatives},
author={Carpentier, Justin and Saurel, Guilhem and Buondonno, Gabriele and Mirabel, Joseph and Lamiraux, Florent and Stasse, Olivier and Mansard, Nicolas},
booktitle={IEEE International Symposium on System Integrations (SII)},
year={2019}
}
And the following one for the link to the GitHub codebase:
@misc{pinocchioweb,
author = {Justin Carpentier and Florian Valenza and Nicolas Mansard and others},
title = {Pinocchio: fast forward and inverse dynamics for poly-articulated systems},
howpublished = {https://stack-of-tasks.github.io/pinocchio},
year = {2015--2021}
}
Citing specific algorithmic contributions
Pinocchio goes beyond implementing the standard rigid-body dynamics algorithms and results from active research on simulation, learning and control. Pinocchio provides state-of-the-art algorithms for handling constraints, differentiating forward and inverse dynamics, etc. If you use these algorithms, please consider citing them in your research articles.
- Le Lidec, Q., Montaut, L. & Carpentier, J. (2024, July). From Compliant to Rigid Contact Simulation: a Unified and Efficient Approach. In RSS 2024-Robotics: Science and Systems.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2024). GJK++: Leveraging Acceleration Methods for Faster Collision Detection. IEEE Transactions on Robotics.
- Sathya, A., & Carpentier, J. (2024). Constrained Articulated Body Dynamics Algorithms. Under review.
- Montaut, L., Le Lidec, Q., Bambade, A., Petrik, V., Sivic, J., & Carpentier, J. (2023, May). Differentiable collision detection: a randomized smoothing approach. In 2023 IEEE International Conference on Robotics and Automation (ICRA).
- Le Lidec, Q., Jallet, W., Montaut, L., Laptev, I., Schmid, C., & Carpentier, J. (2023). Contact models in robotics: a comparative analysis. Under review.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2022, June). Collision Detection Accelerated: An Optimization Perspective. In Robotics: Science and Systems (RSS 2O22).
- Carpentier, J., Budhiraja, R., & Mansard, N. (2021, July). Proximal and sparse resolution of constrained dynamic equations. In Robotics: Science and Systems (RSS 2021).
- Carpentier, J., & Mansard, N. (2018, June). Analytical derivatives of rigid body dynamics algorithms. In Robotics: Science and systems (RSS 2018).
Questions and Issues
Do you have a question or an issue? You may either directly open a new question or a new issue or, directly contact us via the mailing list pinocchio@inria.fr.
Credits
The following people have been involved in the development of Pinocchio and are warmly thanked for their contributions:
- Justin Carpentier (Inria): main developer and manager of the project
- Nicolas Mansard (LAAS-CNRS): initial project instructor
- Guilhem Saurel (LAAS-CNRS): continuous integration and deployment
- Joseph Mirabel (Eureka Robotics): Lie groups and hpp-fcl implementation
- Antonio El Khoury (Wandercraft): bug fixes
- Gabriele Buondono (LAAS-CNRS): features extension, bug fixes, and Python bindings
- Florian Valenza (Astek): core developments and hpp-fcl support
- Wolfgang Merkt (University of Oxford): ROS integration and support
- Rohan Budhiraja (LAAS-CNRS): features extension
- Loïc Estève (Inria): Conda integration and support
- Igor Kalevatykh (Inria): Panda3d viewer support
- Matthieu Vigne (Wandercraft): MeshCat viewer support
- Robin Strudel (Inria): features extension
- François Keith (CEA): Windows support
- Sarah El Kazdadi (Inria): multi-precision arithmetic support
- Nicolas Torres Alberto (Inria): features extension
- Etienne Arlaud (Inria): RViz viewer support
- Wilson Jallet (LAAS-CNRS/Inria): extension of Python bindings
- Fabian Schramm (Inria): core developper
- Shubham Singh (UT Austin): second-order inverse dynamics derivatives
- Stéphane Caron (Inria): core developper
- Joris Vaillant (Inria): core developer and manager of the project
- Sebastian Castro (The AI Institute): MeshCat viewer feature extension
- Lev Kozlov: Kinetic and potential energy regressors
- Megane Millan (Inria): Features extension and core developer
- Simeon Nedelchev: Pseudo inertia and Log-cholesky parametrization
If you have participated in the development of Pinocchio, please add your name and contribution to this list.
Open-source projects relying on Pinocchio
- Crocoddyl: A software to realize model predictive control for complex robotics platforms.
- TSID: A software that implements a Task Space Inverse Dynamics QP.
- HPP: A SDK that implements motion planners for humanoids and other robots.
- Jiminy: A simulator based on Pinocchio.
- ocs2: A toolbox for Optimal Control for Switched Systems (OCS2)
- TriFingerSimulation: TriFinger Robot Simulation (a Robot to perform RL on manipulation).
- Casadi_Kin_Dyn: IIT Package for generation of symbolic (SX) expressions of robot kinematics and dynamics.
- PyRoboPlan: An educational Python library for manipulator motion planning using the Pinocchio Python bindings.
- ProxSuite-NLP: A primal-dual augmented Lagrangian solver for nonlinear programming on manifolds.
- Aligator: A versatile and efficient framework for constrained trajectory optimization.
- Simple: The Simple Simulator: Simulation Made Simple.
- LoIK: Low-Complexity Inverse Kinematics.
Acknowledgments
The development of Pinocchio is actively supported by the Gepetto team @LAAS-CNRS and the Willow team @INRIA.
CONTRIBUTING
Contributing Guidelines
Thank you for your interest in contributing to pinocchio
.
Whether it’s a bug report, new feature, correction, or additional
documentation, we greatly value feedback and contributions from our community.
Please read through this document before submitting any issues or pull requests to ensure we have all the necessary information to effectively respond to your bug report or contribution.
Reporting Bugs/Feature Requests
We welcome you to use the GitHub issue tracker to report bugs or suggest features.
When filing an issue, please check [existing open][issues], or [recently closed][closed-issues], issues to make sure somebody else hasn’t already reported the issue. Please try to include as much information as you can. Details like these are incredibly useful:
- A reproducible test case or series of steps
- The version of our code being used
- Any modifications you’ve made relevant to the bug
- Anything unusual about your environment or deployment
Contributing via Pull Requests
The following guidance should be up-to-date, but the documentation as found here should prove as the final say.
Contributions via pull requests are much appreciated. Before sending us a pull request, please ensure that:
- Limited scope. Your PR should do one thing or one set of things. Avoid adding “random fixes” to PRs. Put those on separate PRs.
- Give your PR a descriptive title. Add a short summary, if required.
- Make sure the pipeline is green.
- Don’t be afraid to request reviews from maintainers.
- New code = new tests. If you are adding new functionality, always make sure to add some tests exercising the code and serving as live documentation of your original intention.
To send us a pull request, please:
- Fork the repository.
- Modify the source; please focus on the specific change you are contributing. If you also reformat all the code, it will be hard for us to focus on your change.
- Ensure local tests pass. (
make test
) - Commit to your fork using clear commit messages.
- Send a pull request, answering any default questions in the pull request interface.
- Pay attention to any automated CI failures reported in the pull request, and stay involved in the conversation.
GitHub provides additional documentation on forking a repository and creating a pull request.
Finding contributions to work on
Looking at the existing issues is a great way to find something to contribute on. As this project, by default, uses the default GitHub issue labels (enhancement/bug/duplicate/help wanted/invalid/question/wontfix), looking at any [‘help wanted’][help-wanted] issues is a great place to start.
Licensing
Any contribution that you make to this repository will be under the BSD Clause 2 License, as dictated by that [license]:
BSD 2-Clause License
Copyright (c) 2014-2021, CNRS
Copyright (c) 2018-2021, INRIA
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the Pinocchio project.
Repository Summary
Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
VCS Type | git |
VCS Version | devel |
Last Updated | 2024-10-14 |
Dev Status | DEVELOPED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
Name | Version |
---|---|
pinocchio | 3.2.0 |
README
Pinocchio instantiates the state-of-the-art Rigid Body Algorithms for poly-articulated systems based on revisited Roy Featherstone’s algorithms. Besides, Pinocchio provides the analytical derivatives of the main Rigid-Body Algorithms, such as the Recursive Newton-Euler Algorithm or the Articulated-Body Algorithm.
Pinocchio was first tailored for robotics applications, but it can be used in other contexts (biomechanics, computer graphics, vision, etc.). It is built upon Eigen for linear algebra and FCL for collision detection. Pinocchio comes with a Python interface for fast code prototyping, directly accessible through Conda.
Pinocchio is now at the heart of various robotics software as Crocoddyl, an open-source and efficient Differential Dynamic Programming solver for robotics, the Stack-of-Tasks, an open-source and versatile hierarchical controller framework or the Humanoid Path Planner, open-source software for Motion and Manipulation Planning.
If you want to learn more about Pinocchio internal behaviors and main features, we invite you to read the related paper and the online documentation.
If you want to dive into Pinocchio directly, only one single line is sufficient (assuming you have Conda):
conda install pinocchio -c conda-forge
or via pip (currently only available on Linux):
pip install pin
Table of contents
- Table of contents
- Introducing Pinocchio 3
- Pinocchio main features
- Documentation
- Examples
- Tutorials
- Pinocchio continuous integrations
- Performances
- Ongoing developments
- Installation
- Visualization
- Citing Pinocchio
- Questions and Issues
- Credits
- Open-source projects relying on Pinocchio
- Acknowledgments
Introducing Pinocchio 3
Pinocchio3 is the latest major release of Pinocchio. It comes with multiple new features, such as:
- Sparse constrained dynamics and its analytical derivatives
- Full support of closed-loop mechanisms
- State-of-the-art frictional contact solvers
- Low-complexity constrained articulated body algorithms
- Full support of multiple-precision floating-point (MPFR) in Python and C++
- Full CasADi support in Python and C++
- Increased support of CppAD and CppADCodeGen
- New SDF and MJCF parsers
- and much more.
Pinocchio main features
Pinocchio is fast:
- C++ template library,
- cache friendly,
- automatic code generation support is available via CppADCodeGen.
Pinocchio is versatile, implementing basic and more advanced rigid body dynamics algorithms:
- forward kinematics and its analytical derivatives,
- forward/inverse dynamics and their analytical derivatives,
- centroidal dynamics and its analytical derivatives,
- support multiple precision arithmetic via Boost.Multiprecision or any similar framework,
- computations of kinematic and dynamic regressors for system identification and more,
- and much more with the support of modern and open-source Automatic Differentiation frameworks like CppAD or CasADi.
Pinocchio is flexible:
- header only,
- C++ 98/03/11/14/17/20 compliant.
Pinocchio is extensible. Pinocchio is multi-thread friendly. Pinocchio is reliable and extensively tested (unit-tests, simulations, and real-world robotics applications). Pinocchio is supported and tested on Windows, Mac OS X, Unix, and Linux (see build status here).
Documentation
The online Pinocchio documentation of the last release is available here. A cheat sheet pdf with the main functions and algorithms can be found here.
Examples
In the examples directory, we provide some basic examples of using Pinocchio in Python. Additional examples introducing Pinocchio are also available in the documentation.
Tutorials
Pinocchio comes with a large bunch of tutorials aiming at introducing the basic tools for robot control. Tutorial and training documents are listed here. You can also consider the interactive Jupyter notebook set of tutorials developed by Nicolas Mansard and Yann de Mont-Marin.
Pinocchio continuous integrations
Pinocchio is constantly tested for several platforms and distributions, as reported below:
CI on ROS | |
CI on Linux via APT | |
CI on OSX via Conda | |
CI on Windows via Conda | |
CI on Linux via Robotpkg |
Performances
Pinocchio exploits, at best, the sparsity induced by the kinematic tree of robotics systems. Thanks to modern programming language paradigms, Pinocchio can unroll most of the computations directly at compile time, allowing to achieve impressive performances for a large range of robots, as illustrated by the plot below, obtained on a standard laptop equipped with an Intel Core i7 CPU @ 2.4 GHz.
For other benchmarks, and mainly the capacity of Pinocchio to exploit, at best, your CPU capacities using advanced code generation techniques, we refer to the technical paper. In addition, the introspection may also help you to understand and compare the performances of the modern rigid body dynamics libraries.
Ongoing developments
If you want to follow the current developments, you can directly refer to the devel branch. The master branch only contains the latest release. Any new Pull Request should then be submitted on the devel branch.
Installation
Pinocchio can be easily installed on various Linux (Ubuntu, Fedora, etc.) and Unix distributions (Mac OS X, BSD, etc.). Please refer to the installation procedure.
If you only need the Python bindings of Pinocchio, you may prefer to install it through Conda. Please follow the procedure described here.
ROS
Pinocchio is also deployed on ROS. You may follow its deployment status below.
If you’re interested in using Pinocchio on systems and/or with packages that integrate with the ROS ecosystem, we recommend the installation of Pinocchio via the binaries distributed via the ROS PPA. Here, you can install Pinocchio using:
sudo apt install ros-$ROS_DISTRO-pinocchio
This installs Pinocchio with HPP-FCL support and with Python bindings. You can then use Pinocchio in your ROS packages by:
- Depending on Pinocchio in your
package.xml
config (<depend>pinocchio</depend>
) - Including Pinocchio via CMake (
find_package(pinocchio REQUIRED)
) and linking against Pinocchio (target_link_libraries(my_library pinocchio::pinocchio)
)
We include support and hooks to discover the package for both ROS 1 and ROS 2. Examples can be found at the following repositories:
Please note that we always advise including the pinocchio/fwd.hpp
header as the first include to avoid compilation errors from differing Boost-variant sizes.
ROS 1 | ROS 2 | |||
---|---|---|---|---|
Melodic | Foxy | |||
Noetic | Galactic | |||
Humble | ||||
Rolling |
Visualization
Pinocchio provides support for many open-source and free visualizers:
- Gepetto Viewer: a C++ viewer based on OpenSceneGraph with Python bindings and Blender export. See here for a C++ example on mixing Pinocchio and Gepetto Viewer.
- Meshcat: supporting visualization in Python and which can be embedded inside any browser.
- Panda3d: supporting visualization in Python and which can be embedded inside any browser.
- RViz: supporting visualization in Python and which can interact with other ROS packages.
Many external viewers can also be integrated. For more information, see the example here.
Citing Pinocchio
To cite Pinocchio in your academic research, please consider citing the software paper and use the following BibTeX entry:
@inproceedings{carpentier2019pinocchio,
title={The Pinocchio C++ library -- A fast and flexible implementation of rigid body dynamics algorithms and their analytical derivatives},
author={Carpentier, Justin and Saurel, Guilhem and Buondonno, Gabriele and Mirabel, Joseph and Lamiraux, Florent and Stasse, Olivier and Mansard, Nicolas},
booktitle={IEEE International Symposium on System Integrations (SII)},
year={2019}
}
And the following one for the link to the GitHub codebase:
@misc{pinocchioweb,
author = {Justin Carpentier and Florian Valenza and Nicolas Mansard and others},
title = {Pinocchio: fast forward and inverse dynamics for poly-articulated systems},
howpublished = {https://stack-of-tasks.github.io/pinocchio},
year = {2015--2021}
}
Citing specific algorithmic contributions
Pinocchio goes beyond implementing the standard rigid-body dynamics algorithms and results from active research on simulation, learning and control. Pinocchio provides state-of-the-art algorithms for handling constraints, differentiating forward and inverse dynamics, etc. If you use these algorithms, please consider citing them in your research articles.
- Le Lidec, Q., Montaut, L. & Carpentier, J. (2024, July). From Compliant to Rigid Contact Simulation: a Unified and Efficient Approach. In RSS 2024-Robotics: Science and Systems.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2024). GJK++: Leveraging Acceleration Methods for Faster Collision Detection. IEEE Transactions on Robotics.
- Sathya, A., & Carpentier, J. (2024). Constrained Articulated Body Dynamics Algorithms. Under review.
- Montaut, L., Le Lidec, Q., Bambade, A., Petrik, V., Sivic, J., & Carpentier, J. (2023, May). Differentiable collision detection: a randomized smoothing approach. In 2023 IEEE International Conference on Robotics and Automation (ICRA).
- Le Lidec, Q., Jallet, W., Montaut, L., Laptev, I., Schmid, C., & Carpentier, J. (2023). Contact models in robotics: a comparative analysis. Under review.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2022, June). Collision Detection Accelerated: An Optimization Perspective. In Robotics: Science and Systems (RSS 2O22).
- Carpentier, J., Budhiraja, R., & Mansard, N. (2021, July). Proximal and sparse resolution of constrained dynamic equations. In Robotics: Science and Systems (RSS 2021).
- Carpentier, J., & Mansard, N. (2018, June). Analytical derivatives of rigid body dynamics algorithms. In Robotics: Science and systems (RSS 2018).
Questions and Issues
Do you have a question or an issue? You may either directly open a new question or a new issue or, directly contact us via the mailing list pinocchio@inria.fr.
Credits
The following people have been involved in the development of Pinocchio and are warmly thanked for their contributions:
- Justin Carpentier (Inria): main developer and manager of the project
- Nicolas Mansard (LAAS-CNRS): initial project instructor
- Guilhem Saurel (LAAS-CNRS): continuous integration and deployment
- Joseph Mirabel (Eureka Robotics): Lie groups and hpp-fcl implementation
- Antonio El Khoury (Wandercraft): bug fixes
- Gabriele Buondono (LAAS-CNRS): features extension, bug fixes, and Python bindings
- Florian Valenza (Astek): core developments and hpp-fcl support
- Wolfgang Merkt (University of Oxford): ROS integration and support
- Rohan Budhiraja (LAAS-CNRS): features extension
- Loïc Estève (Inria): Conda integration and support
- Igor Kalevatykh (Inria): Panda3d viewer support
- Matthieu Vigne (Wandercraft): MeshCat viewer support
- Robin Strudel (Inria): features extension
- François Keith (CEA): Windows support
- Sarah El Kazdadi (Inria): multi-precision arithmetic support
- Nicolas Torres Alberto (Inria): features extension
- Etienne Arlaud (Inria): RViz viewer support
- Wilson Jallet (LAAS-CNRS/Inria): extension of Python bindings
- Fabian Schramm (Inria): core developper
- Shubham Singh (UT Austin): second-order inverse dynamics derivatives
- Stéphane Caron (Inria): core developper
- Joris Vaillant (Inria): core developer and manager of the project
- Sebastian Castro (The AI Institute): MeshCat viewer feature extension
- Lev Kozlov: Kinetic and potential energy regressors
- Megane Millan (Inria): Features extension and core developer
- Simeon Nedelchev: Pseudo inertia and Log-cholesky parametrization
If you have participated in the development of Pinocchio, please add your name and contribution to this list.
Open-source projects relying on Pinocchio
- Crocoddyl: A software to realize model predictive control for complex robotics platforms.
- TSID: A software that implements a Task Space Inverse Dynamics QP.
- HPP: A SDK that implements motion planners for humanoids and other robots.
- Jiminy: A simulator based on Pinocchio.
- ocs2: A toolbox for Optimal Control for Switched Systems (OCS2)
- TriFingerSimulation: TriFinger Robot Simulation (a Robot to perform RL on manipulation).
- Casadi_Kin_Dyn: IIT Package for generation of symbolic (SX) expressions of robot kinematics and dynamics.
- PyRoboPlan: An educational Python library for manipulator motion planning using the Pinocchio Python bindings.
- ProxSuite-NLP: A primal-dual augmented Lagrangian solver for nonlinear programming on manifolds.
- Aligator: A versatile and efficient framework for constrained trajectory optimization.
- Simple: The Simple Simulator: Simulation Made Simple.
- LoIK: Low-Complexity Inverse Kinematics.
Acknowledgments
The development of Pinocchio is actively supported by the Gepetto team @LAAS-CNRS and the Willow team @INRIA.
CONTRIBUTING
Contributing Guidelines
Thank you for your interest in contributing to pinocchio
.
Whether it’s a bug report, new feature, correction, or additional
documentation, we greatly value feedback and contributions from our community.
Please read through this document before submitting any issues or pull requests to ensure we have all the necessary information to effectively respond to your bug report or contribution.
Reporting Bugs/Feature Requests
We welcome you to use the GitHub issue tracker to report bugs or suggest features.
When filing an issue, please check [existing open][issues], or [recently closed][closed-issues], issues to make sure somebody else hasn’t already reported the issue. Please try to include as much information as you can. Details like these are incredibly useful:
- A reproducible test case or series of steps
- The version of our code being used
- Any modifications you’ve made relevant to the bug
- Anything unusual about your environment or deployment
Contributing via Pull Requests
The following guidance should be up-to-date, but the documentation as found here should prove as the final say.
Contributions via pull requests are much appreciated. Before sending us a pull request, please ensure that:
- Limited scope. Your PR should do one thing or one set of things. Avoid adding “random fixes” to PRs. Put those on separate PRs.
- Give your PR a descriptive title. Add a short summary, if required.
- Make sure the pipeline is green.
- Don’t be afraid to request reviews from maintainers.
- New code = new tests. If you are adding new functionality, always make sure to add some tests exercising the code and serving as live documentation of your original intention.
To send us a pull request, please:
- Fork the repository.
- Modify the source; please focus on the specific change you are contributing. If you also reformat all the code, it will be hard for us to focus on your change.
- Ensure local tests pass. (
make test
) - Commit to your fork using clear commit messages.
- Send a pull request, answering any default questions in the pull request interface.
- Pay attention to any automated CI failures reported in the pull request, and stay involved in the conversation.
GitHub provides additional documentation on forking a repository and creating a pull request.
Finding contributions to work on
Looking at the existing issues is a great way to find something to contribute on. As this project, by default, uses the default GitHub issue labels (enhancement/bug/duplicate/help wanted/invalid/question/wontfix), looking at any [‘help wanted’][help-wanted] issues is a great place to start.
Licensing
Any contribution that you make to this repository will be under the BSD Clause 2 License, as dictated by that [license]:
BSD 2-Clause License
Copyright (c) 2014-2021, CNRS
Copyright (c) 2018-2021, INRIA
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the Pinocchio project.
Repository Summary
Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
VCS Type | git |
VCS Version | devel |
Last Updated | 2024-10-14 |
Dev Status | DEVELOPED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
Name | Version |
---|---|
pinocchio | 3.2.0 |
README
Pinocchio instantiates the state-of-the-art Rigid Body Algorithms for poly-articulated systems based on revisited Roy Featherstone’s algorithms. Besides, Pinocchio provides the analytical derivatives of the main Rigid-Body Algorithms, such as the Recursive Newton-Euler Algorithm or the Articulated-Body Algorithm.
Pinocchio was first tailored for robotics applications, but it can be used in other contexts (biomechanics, computer graphics, vision, etc.). It is built upon Eigen for linear algebra and FCL for collision detection. Pinocchio comes with a Python interface for fast code prototyping, directly accessible through Conda.
Pinocchio is now at the heart of various robotics software as Crocoddyl, an open-source and efficient Differential Dynamic Programming solver for robotics, the Stack-of-Tasks, an open-source and versatile hierarchical controller framework or the Humanoid Path Planner, open-source software for Motion and Manipulation Planning.
If you want to learn more about Pinocchio internal behaviors and main features, we invite you to read the related paper and the online documentation.
If you want to dive into Pinocchio directly, only one single line is sufficient (assuming you have Conda):
conda install pinocchio -c conda-forge
or via pip (currently only available on Linux):
pip install pin
Table of contents
- Table of contents
- Introducing Pinocchio 3
- Pinocchio main features
- Documentation
- Examples
- Tutorials
- Pinocchio continuous integrations
- Performances
- Ongoing developments
- Installation
- Visualization
- Citing Pinocchio
- Questions and Issues
- Credits
- Open-source projects relying on Pinocchio
- Acknowledgments
Introducing Pinocchio 3
Pinocchio3 is the latest major release of Pinocchio. It comes with multiple new features, such as:
- Sparse constrained dynamics and its analytical derivatives
- Full support of closed-loop mechanisms
- State-of-the-art frictional contact solvers
- Low-complexity constrained articulated body algorithms
- Full support of multiple-precision floating-point (MPFR) in Python and C++
- Full CasADi support in Python and C++
- Increased support of CppAD and CppADCodeGen
- New SDF and MJCF parsers
- and much more.
Pinocchio main features
Pinocchio is fast:
- C++ template library,
- cache friendly,
- automatic code generation support is available via CppADCodeGen.
Pinocchio is versatile, implementing basic and more advanced rigid body dynamics algorithms:
- forward kinematics and its analytical derivatives,
- forward/inverse dynamics and their analytical derivatives,
- centroidal dynamics and its analytical derivatives,
- support multiple precision arithmetic via Boost.Multiprecision or any similar framework,
- computations of kinematic and dynamic regressors for system identification and more,
- and much more with the support of modern and open-source Automatic Differentiation frameworks like CppAD or CasADi.
Pinocchio is flexible:
- header only,
- C++ 98/03/11/14/17/20 compliant.
Pinocchio is extensible. Pinocchio is multi-thread friendly. Pinocchio is reliable and extensively tested (unit-tests, simulations, and real-world robotics applications). Pinocchio is supported and tested on Windows, Mac OS X, Unix, and Linux (see build status here).
Documentation
The online Pinocchio documentation of the last release is available here. A cheat sheet pdf with the main functions and algorithms can be found here.
Examples
In the examples directory, we provide some basic examples of using Pinocchio in Python. Additional examples introducing Pinocchio are also available in the documentation.
Tutorials
Pinocchio comes with a large bunch of tutorials aiming at introducing the basic tools for robot control. Tutorial and training documents are listed here. You can also consider the interactive Jupyter notebook set of tutorials developed by Nicolas Mansard and Yann de Mont-Marin.
Pinocchio continuous integrations
Pinocchio is constantly tested for several platforms and distributions, as reported below:
CI on ROS | |
CI on Linux via APT | |
CI on OSX via Conda | |
CI on Windows via Conda | |
CI on Linux via Robotpkg |
Performances
Pinocchio exploits, at best, the sparsity induced by the kinematic tree of robotics systems. Thanks to modern programming language paradigms, Pinocchio can unroll most of the computations directly at compile time, allowing to achieve impressive performances for a large range of robots, as illustrated by the plot below, obtained on a standard laptop equipped with an Intel Core i7 CPU @ 2.4 GHz.
For other benchmarks, and mainly the capacity of Pinocchio to exploit, at best, your CPU capacities using advanced code generation techniques, we refer to the technical paper. In addition, the introspection may also help you to understand and compare the performances of the modern rigid body dynamics libraries.
Ongoing developments
If you want to follow the current developments, you can directly refer to the devel branch. The master branch only contains the latest release. Any new Pull Request should then be submitted on the devel branch.
Installation
Pinocchio can be easily installed on various Linux (Ubuntu, Fedora, etc.) and Unix distributions (Mac OS X, BSD, etc.). Please refer to the installation procedure.
If you only need the Python bindings of Pinocchio, you may prefer to install it through Conda. Please follow the procedure described here.
ROS
Pinocchio is also deployed on ROS. You may follow its deployment status below.
If you’re interested in using Pinocchio on systems and/or with packages that integrate with the ROS ecosystem, we recommend the installation of Pinocchio via the binaries distributed via the ROS PPA. Here, you can install Pinocchio using:
sudo apt install ros-$ROS_DISTRO-pinocchio
This installs Pinocchio with HPP-FCL support and with Python bindings. You can then use Pinocchio in your ROS packages by:
- Depending on Pinocchio in your
package.xml
config (<depend>pinocchio</depend>
) - Including Pinocchio via CMake (
find_package(pinocchio REQUIRED)
) and linking against Pinocchio (target_link_libraries(my_library pinocchio::pinocchio)
)
We include support and hooks to discover the package for both ROS 1 and ROS 2. Examples can be found at the following repositories:
Please note that we always advise including the pinocchio/fwd.hpp
header as the first include to avoid compilation errors from differing Boost-variant sizes.
ROS 1 | ROS 2 | |||
---|---|---|---|---|
Melodic | Foxy | |||
Noetic | Galactic | |||
Humble | ||||
Rolling |
Visualization
Pinocchio provides support for many open-source and free visualizers:
- Gepetto Viewer: a C++ viewer based on OpenSceneGraph with Python bindings and Blender export. See here for a C++ example on mixing Pinocchio and Gepetto Viewer.
- Meshcat: supporting visualization in Python and which can be embedded inside any browser.
- Panda3d: supporting visualization in Python and which can be embedded inside any browser.
- RViz: supporting visualization in Python and which can interact with other ROS packages.
Many external viewers can also be integrated. For more information, see the example here.
Citing Pinocchio
To cite Pinocchio in your academic research, please consider citing the software paper and use the following BibTeX entry:
@inproceedings{carpentier2019pinocchio,
title={The Pinocchio C++ library -- A fast and flexible implementation of rigid body dynamics algorithms and their analytical derivatives},
author={Carpentier, Justin and Saurel, Guilhem and Buondonno, Gabriele and Mirabel, Joseph and Lamiraux, Florent and Stasse, Olivier and Mansard, Nicolas},
booktitle={IEEE International Symposium on System Integrations (SII)},
year={2019}
}
And the following one for the link to the GitHub codebase:
@misc{pinocchioweb,
author = {Justin Carpentier and Florian Valenza and Nicolas Mansard and others},
title = {Pinocchio: fast forward and inverse dynamics for poly-articulated systems},
howpublished = {https://stack-of-tasks.github.io/pinocchio},
year = {2015--2021}
}
Citing specific algorithmic contributions
Pinocchio goes beyond implementing the standard rigid-body dynamics algorithms and results from active research on simulation, learning and control. Pinocchio provides state-of-the-art algorithms for handling constraints, differentiating forward and inverse dynamics, etc. If you use these algorithms, please consider citing them in your research articles.
- Le Lidec, Q., Montaut, L. & Carpentier, J. (2024, July). From Compliant to Rigid Contact Simulation: a Unified and Efficient Approach. In RSS 2024-Robotics: Science and Systems.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2024). GJK++: Leveraging Acceleration Methods for Faster Collision Detection. IEEE Transactions on Robotics.
- Sathya, A., & Carpentier, J. (2024). Constrained Articulated Body Dynamics Algorithms. Under review.
- Montaut, L., Le Lidec, Q., Bambade, A., Petrik, V., Sivic, J., & Carpentier, J. (2023, May). Differentiable collision detection: a randomized smoothing approach. In 2023 IEEE International Conference on Robotics and Automation (ICRA).
- Le Lidec, Q., Jallet, W., Montaut, L., Laptev, I., Schmid, C., & Carpentier, J. (2023). Contact models in robotics: a comparative analysis. Under review.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2022, June). Collision Detection Accelerated: An Optimization Perspective. In Robotics: Science and Systems (RSS 2O22).
- Carpentier, J., Budhiraja, R., & Mansard, N. (2021, July). Proximal and sparse resolution of constrained dynamic equations. In Robotics: Science and Systems (RSS 2021).
- Carpentier, J., & Mansard, N. (2018, June). Analytical derivatives of rigid body dynamics algorithms. In Robotics: Science and systems (RSS 2018).
Questions and Issues
Do you have a question or an issue? You may either directly open a new question or a new issue or, directly contact us via the mailing list pinocchio@inria.fr.
Credits
The following people have been involved in the development of Pinocchio and are warmly thanked for their contributions:
- Justin Carpentier (Inria): main developer and manager of the project
- Nicolas Mansard (LAAS-CNRS): initial project instructor
- Guilhem Saurel (LAAS-CNRS): continuous integration and deployment
- Joseph Mirabel (Eureka Robotics): Lie groups and hpp-fcl implementation
- Antonio El Khoury (Wandercraft): bug fixes
- Gabriele Buondono (LAAS-CNRS): features extension, bug fixes, and Python bindings
- Florian Valenza (Astek): core developments and hpp-fcl support
- Wolfgang Merkt (University of Oxford): ROS integration and support
- Rohan Budhiraja (LAAS-CNRS): features extension
- Loïc Estève (Inria): Conda integration and support
- Igor Kalevatykh (Inria): Panda3d viewer support
- Matthieu Vigne (Wandercraft): MeshCat viewer support
- Robin Strudel (Inria): features extension
- François Keith (CEA): Windows support
- Sarah El Kazdadi (Inria): multi-precision arithmetic support
- Nicolas Torres Alberto (Inria): features extension
- Etienne Arlaud (Inria): RViz viewer support
- Wilson Jallet (LAAS-CNRS/Inria): extension of Python bindings
- Fabian Schramm (Inria): core developper
- Shubham Singh (UT Austin): second-order inverse dynamics derivatives
- Stéphane Caron (Inria): core developper
- Joris Vaillant (Inria): core developer and manager of the project
- Sebastian Castro (The AI Institute): MeshCat viewer feature extension
- Lev Kozlov: Kinetic and potential energy regressors
- Megane Millan (Inria): Features extension and core developer
- Simeon Nedelchev: Pseudo inertia and Log-cholesky parametrization
If you have participated in the development of Pinocchio, please add your name and contribution to this list.
Open-source projects relying on Pinocchio
- Crocoddyl: A software to realize model predictive control for complex robotics platforms.
- TSID: A software that implements a Task Space Inverse Dynamics QP.
- HPP: A SDK that implements motion planners for humanoids and other robots.
- Jiminy: A simulator based on Pinocchio.
- ocs2: A toolbox for Optimal Control for Switched Systems (OCS2)
- TriFingerSimulation: TriFinger Robot Simulation (a Robot to perform RL on manipulation).
- Casadi_Kin_Dyn: IIT Package for generation of symbolic (SX) expressions of robot kinematics and dynamics.
- PyRoboPlan: An educational Python library for manipulator motion planning using the Pinocchio Python bindings.
- ProxSuite-NLP: A primal-dual augmented Lagrangian solver for nonlinear programming on manifolds.
- Aligator: A versatile and efficient framework for constrained trajectory optimization.
- Simple: The Simple Simulator: Simulation Made Simple.
- LoIK: Low-Complexity Inverse Kinematics.
Acknowledgments
The development of Pinocchio is actively supported by the Gepetto team @LAAS-CNRS and the Willow team @INRIA.
CONTRIBUTING
Contributing Guidelines
Thank you for your interest in contributing to pinocchio
.
Whether it’s a bug report, new feature, correction, or additional
documentation, we greatly value feedback and contributions from our community.
Please read through this document before submitting any issues or pull requests to ensure we have all the necessary information to effectively respond to your bug report or contribution.
Reporting Bugs/Feature Requests
We welcome you to use the GitHub issue tracker to report bugs or suggest features.
When filing an issue, please check [existing open][issues], or [recently closed][closed-issues], issues to make sure somebody else hasn’t already reported the issue. Please try to include as much information as you can. Details like these are incredibly useful:
- A reproducible test case or series of steps
- The version of our code being used
- Any modifications you’ve made relevant to the bug
- Anything unusual about your environment or deployment
Contributing via Pull Requests
The following guidance should be up-to-date, but the documentation as found here should prove as the final say.
Contributions via pull requests are much appreciated. Before sending us a pull request, please ensure that:
- Limited scope. Your PR should do one thing or one set of things. Avoid adding “random fixes” to PRs. Put those on separate PRs.
- Give your PR a descriptive title. Add a short summary, if required.
- Make sure the pipeline is green.
- Don’t be afraid to request reviews from maintainers.
- New code = new tests. If you are adding new functionality, always make sure to add some tests exercising the code and serving as live documentation of your original intention.
To send us a pull request, please:
- Fork the repository.
- Modify the source; please focus on the specific change you are contributing. If you also reformat all the code, it will be hard for us to focus on your change.
- Ensure local tests pass. (
make test
) - Commit to your fork using clear commit messages.
- Send a pull request, answering any default questions in the pull request interface.
- Pay attention to any automated CI failures reported in the pull request, and stay involved in the conversation.
GitHub provides additional documentation on forking a repository and creating a pull request.
Finding contributions to work on
Looking at the existing issues is a great way to find something to contribute on. As this project, by default, uses the default GitHub issue labels (enhancement/bug/duplicate/help wanted/invalid/question/wontfix), looking at any [‘help wanted’][help-wanted] issues is a great place to start.
Licensing
Any contribution that you make to this repository will be under the BSD Clause 2 License, as dictated by that [license]:
BSD 2-Clause License
Copyright (c) 2014-2021, CNRS
Copyright (c) 2018-2021, INRIA
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the Pinocchio project.
Repository Summary
Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
VCS Type | git |
VCS Version | devel |
Last Updated | 2024-10-14 |
Dev Status | DEVELOPED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
Name | Version |
---|---|
pinocchio | 3.2.0 |
README
Pinocchio instantiates the state-of-the-art Rigid Body Algorithms for poly-articulated systems based on revisited Roy Featherstone’s algorithms. Besides, Pinocchio provides the analytical derivatives of the main Rigid-Body Algorithms, such as the Recursive Newton-Euler Algorithm or the Articulated-Body Algorithm.
Pinocchio was first tailored for robotics applications, but it can be used in other contexts (biomechanics, computer graphics, vision, etc.). It is built upon Eigen for linear algebra and FCL for collision detection. Pinocchio comes with a Python interface for fast code prototyping, directly accessible through Conda.
Pinocchio is now at the heart of various robotics software as Crocoddyl, an open-source and efficient Differential Dynamic Programming solver for robotics, the Stack-of-Tasks, an open-source and versatile hierarchical controller framework or the Humanoid Path Planner, open-source software for Motion and Manipulation Planning.
If you want to learn more about Pinocchio internal behaviors and main features, we invite you to read the related paper and the online documentation.
If you want to dive into Pinocchio directly, only one single line is sufficient (assuming you have Conda):
conda install pinocchio -c conda-forge
or via pip (currently only available on Linux):
pip install pin
Table of contents
- Table of contents
- Introducing Pinocchio 3
- Pinocchio main features
- Documentation
- Examples
- Tutorials
- Pinocchio continuous integrations
- Performances
- Ongoing developments
- Installation
- Visualization
- Citing Pinocchio
- Questions and Issues
- Credits
- Open-source projects relying on Pinocchio
- Acknowledgments
Introducing Pinocchio 3
Pinocchio3 is the latest major release of Pinocchio. It comes with multiple new features, such as:
- Sparse constrained dynamics and its analytical derivatives
- Full support of closed-loop mechanisms
- State-of-the-art frictional contact solvers
- Low-complexity constrained articulated body algorithms
- Full support of multiple-precision floating-point (MPFR) in Python and C++
- Full CasADi support in Python and C++
- Increased support of CppAD and CppADCodeGen
- New SDF and MJCF parsers
- and much more.
Pinocchio main features
Pinocchio is fast:
- C++ template library,
- cache friendly,
- automatic code generation support is available via CppADCodeGen.
Pinocchio is versatile, implementing basic and more advanced rigid body dynamics algorithms:
- forward kinematics and its analytical derivatives,
- forward/inverse dynamics and their analytical derivatives,
- centroidal dynamics and its analytical derivatives,
- support multiple precision arithmetic via Boost.Multiprecision or any similar framework,
- computations of kinematic and dynamic regressors for system identification and more,
- and much more with the support of modern and open-source Automatic Differentiation frameworks like CppAD or CasADi.
Pinocchio is flexible:
- header only,
- C++ 98/03/11/14/17/20 compliant.
Pinocchio is extensible. Pinocchio is multi-thread friendly. Pinocchio is reliable and extensively tested (unit-tests, simulations, and real-world robotics applications). Pinocchio is supported and tested on Windows, Mac OS X, Unix, and Linux (see build status here).
Documentation
The online Pinocchio documentation of the last release is available here. A cheat sheet pdf with the main functions and algorithms can be found here.
Examples
In the examples directory, we provide some basic examples of using Pinocchio in Python. Additional examples introducing Pinocchio are also available in the documentation.
Tutorials
Pinocchio comes with a large bunch of tutorials aiming at introducing the basic tools for robot control. Tutorial and training documents are listed here. You can also consider the interactive Jupyter notebook set of tutorials developed by Nicolas Mansard and Yann de Mont-Marin.
Pinocchio continuous integrations
Pinocchio is constantly tested for several platforms and distributions, as reported below:
CI on ROS | |
CI on Linux via APT | |
CI on OSX via Conda | |
CI on Windows via Conda | |
CI on Linux via Robotpkg |
Performances
Pinocchio exploits, at best, the sparsity induced by the kinematic tree of robotics systems. Thanks to modern programming language paradigms, Pinocchio can unroll most of the computations directly at compile time, allowing to achieve impressive performances for a large range of robots, as illustrated by the plot below, obtained on a standard laptop equipped with an Intel Core i7 CPU @ 2.4 GHz.
For other benchmarks, and mainly the capacity of Pinocchio to exploit, at best, your CPU capacities using advanced code generation techniques, we refer to the technical paper. In addition, the introspection may also help you to understand and compare the performances of the modern rigid body dynamics libraries.
Ongoing developments
If you want to follow the current developments, you can directly refer to the devel branch. The master branch only contains the latest release. Any new Pull Request should then be submitted on the devel branch.
Installation
Pinocchio can be easily installed on various Linux (Ubuntu, Fedora, etc.) and Unix distributions (Mac OS X, BSD, etc.). Please refer to the installation procedure.
If you only need the Python bindings of Pinocchio, you may prefer to install it through Conda. Please follow the procedure described here.
ROS
Pinocchio is also deployed on ROS. You may follow its deployment status below.
If you’re interested in using Pinocchio on systems and/or with packages that integrate with the ROS ecosystem, we recommend the installation of Pinocchio via the binaries distributed via the ROS PPA. Here, you can install Pinocchio using:
sudo apt install ros-$ROS_DISTRO-pinocchio
This installs Pinocchio with HPP-FCL support and with Python bindings. You can then use Pinocchio in your ROS packages by:
- Depending on Pinocchio in your
package.xml
config (<depend>pinocchio</depend>
) - Including Pinocchio via CMake (
find_package(pinocchio REQUIRED)
) and linking against Pinocchio (target_link_libraries(my_library pinocchio::pinocchio)
)
We include support and hooks to discover the package for both ROS 1 and ROS 2. Examples can be found at the following repositories:
Please note that we always advise including the pinocchio/fwd.hpp
header as the first include to avoid compilation errors from differing Boost-variant sizes.
ROS 1 | ROS 2 | |||
---|---|---|---|---|
Melodic | Foxy | |||
Noetic | Galactic | |||
Humble | ||||
Rolling |
Visualization
Pinocchio provides support for many open-source and free visualizers:
- Gepetto Viewer: a C++ viewer based on OpenSceneGraph with Python bindings and Blender export. See here for a C++ example on mixing Pinocchio and Gepetto Viewer.
- Meshcat: supporting visualization in Python and which can be embedded inside any browser.
- Panda3d: supporting visualization in Python and which can be embedded inside any browser.
- RViz: supporting visualization in Python and which can interact with other ROS packages.
Many external viewers can also be integrated. For more information, see the example here.
Citing Pinocchio
To cite Pinocchio in your academic research, please consider citing the software paper and use the following BibTeX entry:
@inproceedings{carpentier2019pinocchio,
title={The Pinocchio C++ library -- A fast and flexible implementation of rigid body dynamics algorithms and their analytical derivatives},
author={Carpentier, Justin and Saurel, Guilhem and Buondonno, Gabriele and Mirabel, Joseph and Lamiraux, Florent and Stasse, Olivier and Mansard, Nicolas},
booktitle={IEEE International Symposium on System Integrations (SII)},
year={2019}
}
And the following one for the link to the GitHub codebase:
@misc{pinocchioweb,
author = {Justin Carpentier and Florian Valenza and Nicolas Mansard and others},
title = {Pinocchio: fast forward and inverse dynamics for poly-articulated systems},
howpublished = {https://stack-of-tasks.github.io/pinocchio},
year = {2015--2021}
}
Citing specific algorithmic contributions
Pinocchio goes beyond implementing the standard rigid-body dynamics algorithms and results from active research on simulation, learning and control. Pinocchio provides state-of-the-art algorithms for handling constraints, differentiating forward and inverse dynamics, etc. If you use these algorithms, please consider citing them in your research articles.
- Le Lidec, Q., Montaut, L. & Carpentier, J. (2024, July). From Compliant to Rigid Contact Simulation: a Unified and Efficient Approach. In RSS 2024-Robotics: Science and Systems.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2024). GJK++: Leveraging Acceleration Methods for Faster Collision Detection. IEEE Transactions on Robotics.
- Sathya, A., & Carpentier, J. (2024). Constrained Articulated Body Dynamics Algorithms. Under review.
- Montaut, L., Le Lidec, Q., Bambade, A., Petrik, V., Sivic, J., & Carpentier, J. (2023, May). Differentiable collision detection: a randomized smoothing approach. In 2023 IEEE International Conference on Robotics and Automation (ICRA).
- Le Lidec, Q., Jallet, W., Montaut, L., Laptev, I., Schmid, C., & Carpentier, J. (2023). Contact models in robotics: a comparative analysis. Under review.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2022, June). Collision Detection Accelerated: An Optimization Perspective. In Robotics: Science and Systems (RSS 2O22).
- Carpentier, J., Budhiraja, R., & Mansard, N. (2021, July). Proximal and sparse resolution of constrained dynamic equations. In Robotics: Science and Systems (RSS 2021).
- Carpentier, J., & Mansard, N. (2018, June). Analytical derivatives of rigid body dynamics algorithms. In Robotics: Science and systems (RSS 2018).
Questions and Issues
Do you have a question or an issue? You may either directly open a new question or a new issue or, directly contact us via the mailing list pinocchio@inria.fr.
Credits
The following people have been involved in the development of Pinocchio and are warmly thanked for their contributions:
- Justin Carpentier (Inria): main developer and manager of the project
- Nicolas Mansard (LAAS-CNRS): initial project instructor
- Guilhem Saurel (LAAS-CNRS): continuous integration and deployment
- Joseph Mirabel (Eureka Robotics): Lie groups and hpp-fcl implementation
- Antonio El Khoury (Wandercraft): bug fixes
- Gabriele Buondono (LAAS-CNRS): features extension, bug fixes, and Python bindings
- Florian Valenza (Astek): core developments and hpp-fcl support
- Wolfgang Merkt (University of Oxford): ROS integration and support
- Rohan Budhiraja (LAAS-CNRS): features extension
- Loïc Estève (Inria): Conda integration and support
- Igor Kalevatykh (Inria): Panda3d viewer support
- Matthieu Vigne (Wandercraft): MeshCat viewer support
- Robin Strudel (Inria): features extension
- François Keith (CEA): Windows support
- Sarah El Kazdadi (Inria): multi-precision arithmetic support
- Nicolas Torres Alberto (Inria): features extension
- Etienne Arlaud (Inria): RViz viewer support
- Wilson Jallet (LAAS-CNRS/Inria): extension of Python bindings
- Fabian Schramm (Inria): core developper
- Shubham Singh (UT Austin): second-order inverse dynamics derivatives
- Stéphane Caron (Inria): core developper
- Joris Vaillant (Inria): core developer and manager of the project
- Sebastian Castro (The AI Institute): MeshCat viewer feature extension
- Lev Kozlov: Kinetic and potential energy regressors
- Megane Millan (Inria): Features extension and core developer
- Simeon Nedelchev: Pseudo inertia and Log-cholesky parametrization
If you have participated in the development of Pinocchio, please add your name and contribution to this list.
Open-source projects relying on Pinocchio
- Crocoddyl: A software to realize model predictive control for complex robotics platforms.
- TSID: A software that implements a Task Space Inverse Dynamics QP.
- HPP: A SDK that implements motion planners for humanoids and other robots.
- Jiminy: A simulator based on Pinocchio.
- ocs2: A toolbox for Optimal Control for Switched Systems (OCS2)
- TriFingerSimulation: TriFinger Robot Simulation (a Robot to perform RL on manipulation).
- Casadi_Kin_Dyn: IIT Package for generation of symbolic (SX) expressions of robot kinematics and dynamics.
- PyRoboPlan: An educational Python library for manipulator motion planning using the Pinocchio Python bindings.
- ProxSuite-NLP: A primal-dual augmented Lagrangian solver for nonlinear programming on manifolds.
- Aligator: A versatile and efficient framework for constrained trajectory optimization.
- Simple: The Simple Simulator: Simulation Made Simple.
- LoIK: Low-Complexity Inverse Kinematics.
Acknowledgments
The development of Pinocchio is actively supported by the Gepetto team @LAAS-CNRS and the Willow team @INRIA.
CONTRIBUTING
Contributing Guidelines
Thank you for your interest in contributing to pinocchio
.
Whether it’s a bug report, new feature, correction, or additional
documentation, we greatly value feedback and contributions from our community.
Please read through this document before submitting any issues or pull requests to ensure we have all the necessary information to effectively respond to your bug report or contribution.
Reporting Bugs/Feature Requests
We welcome you to use the GitHub issue tracker to report bugs or suggest features.
When filing an issue, please check [existing open][issues], or [recently closed][closed-issues], issues to make sure somebody else hasn’t already reported the issue. Please try to include as much information as you can. Details like these are incredibly useful:
- A reproducible test case or series of steps
- The version of our code being used
- Any modifications you’ve made relevant to the bug
- Anything unusual about your environment or deployment
Contributing via Pull Requests
The following guidance should be up-to-date, but the documentation as found here should prove as the final say.
Contributions via pull requests are much appreciated. Before sending us a pull request, please ensure that:
- Limited scope. Your PR should do one thing or one set of things. Avoid adding “random fixes” to PRs. Put those on separate PRs.
- Give your PR a descriptive title. Add a short summary, if required.
- Make sure the pipeline is green.
- Don’t be afraid to request reviews from maintainers.
- New code = new tests. If you are adding new functionality, always make sure to add some tests exercising the code and serving as live documentation of your original intention.
To send us a pull request, please:
- Fork the repository.
- Modify the source; please focus on the specific change you are contributing. If you also reformat all the code, it will be hard for us to focus on your change.
- Ensure local tests pass. (
make test
) - Commit to your fork using clear commit messages.
- Send a pull request, answering any default questions in the pull request interface.
- Pay attention to any automated CI failures reported in the pull request, and stay involved in the conversation.
GitHub provides additional documentation on forking a repository and creating a pull request.
Finding contributions to work on
Looking at the existing issues is a great way to find something to contribute on. As this project, by default, uses the default GitHub issue labels (enhancement/bug/duplicate/help wanted/invalid/question/wontfix), looking at any [‘help wanted’][help-wanted] issues is a great place to start.
Licensing
Any contribution that you make to this repository will be under the BSD Clause 2 License, as dictated by that [license]:
BSD 2-Clause License
Copyright (c) 2014-2021, CNRS
Copyright (c) 2018-2021, INRIA
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the Pinocchio project.
Repository Summary
Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
VCS Type | git |
VCS Version | devel |
Last Updated | 2024-10-14 |
Dev Status | DEVELOPED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
Name | Version |
---|---|
pinocchio | 3.2.0 |
README
Pinocchio instantiates the state-of-the-art Rigid Body Algorithms for poly-articulated systems based on revisited Roy Featherstone’s algorithms. Besides, Pinocchio provides the analytical derivatives of the main Rigid-Body Algorithms, such as the Recursive Newton-Euler Algorithm or the Articulated-Body Algorithm.
Pinocchio was first tailored for robotics applications, but it can be used in other contexts (biomechanics, computer graphics, vision, etc.). It is built upon Eigen for linear algebra and FCL for collision detection. Pinocchio comes with a Python interface for fast code prototyping, directly accessible through Conda.
Pinocchio is now at the heart of various robotics software as Crocoddyl, an open-source and efficient Differential Dynamic Programming solver for robotics, the Stack-of-Tasks, an open-source and versatile hierarchical controller framework or the Humanoid Path Planner, open-source software for Motion and Manipulation Planning.
If you want to learn more about Pinocchio internal behaviors and main features, we invite you to read the related paper and the online documentation.
If you want to dive into Pinocchio directly, only one single line is sufficient (assuming you have Conda):
conda install pinocchio -c conda-forge
or via pip (currently only available on Linux):
pip install pin
Table of contents
- Table of contents
- Introducing Pinocchio 3
- Pinocchio main features
- Documentation
- Examples
- Tutorials
- Pinocchio continuous integrations
- Performances
- Ongoing developments
- Installation
- Visualization
- Citing Pinocchio
- Questions and Issues
- Credits
- Open-source projects relying on Pinocchio
- Acknowledgments
Introducing Pinocchio 3
Pinocchio3 is the latest major release of Pinocchio. It comes with multiple new features, such as:
- Sparse constrained dynamics and its analytical derivatives
- Full support of closed-loop mechanisms
- State-of-the-art frictional contact solvers
- Low-complexity constrained articulated body algorithms
- Full support of multiple-precision floating-point (MPFR) in Python and C++
- Full CasADi support in Python and C++
- Increased support of CppAD and CppADCodeGen
- New SDF and MJCF parsers
- and much more.
Pinocchio main features
Pinocchio is fast:
- C++ template library,
- cache friendly,
- automatic code generation support is available via CppADCodeGen.
Pinocchio is versatile, implementing basic and more advanced rigid body dynamics algorithms:
- forward kinematics and its analytical derivatives,
- forward/inverse dynamics and their analytical derivatives,
- centroidal dynamics and its analytical derivatives,
- support multiple precision arithmetic via Boost.Multiprecision or any similar framework,
- computations of kinematic and dynamic regressors for system identification and more,
- and much more with the support of modern and open-source Automatic Differentiation frameworks like CppAD or CasADi.
Pinocchio is flexible:
- header only,
- C++ 98/03/11/14/17/20 compliant.
Pinocchio is extensible. Pinocchio is multi-thread friendly. Pinocchio is reliable and extensively tested (unit-tests, simulations, and real-world robotics applications). Pinocchio is supported and tested on Windows, Mac OS X, Unix, and Linux (see build status here).
Documentation
The online Pinocchio documentation of the last release is available here. A cheat sheet pdf with the main functions and algorithms can be found here.
Examples
In the examples directory, we provide some basic examples of using Pinocchio in Python. Additional examples introducing Pinocchio are also available in the documentation.
Tutorials
Pinocchio comes with a large bunch of tutorials aiming at introducing the basic tools for robot control. Tutorial and training documents are listed here. You can also consider the interactive Jupyter notebook set of tutorials developed by Nicolas Mansard and Yann de Mont-Marin.
Pinocchio continuous integrations
Pinocchio is constantly tested for several platforms and distributions, as reported below:
CI on ROS | |
CI on Linux via APT | |
CI on OSX via Conda | |
CI on Windows via Conda | |
CI on Linux via Robotpkg |
Performances
Pinocchio exploits, at best, the sparsity induced by the kinematic tree of robotics systems. Thanks to modern programming language paradigms, Pinocchio can unroll most of the computations directly at compile time, allowing to achieve impressive performances for a large range of robots, as illustrated by the plot below, obtained on a standard laptop equipped with an Intel Core i7 CPU @ 2.4 GHz.
For other benchmarks, and mainly the capacity of Pinocchio to exploit, at best, your CPU capacities using advanced code generation techniques, we refer to the technical paper. In addition, the introspection may also help you to understand and compare the performances of the modern rigid body dynamics libraries.
Ongoing developments
If you want to follow the current developments, you can directly refer to the devel branch. The master branch only contains the latest release. Any new Pull Request should then be submitted on the devel branch.
Installation
Pinocchio can be easily installed on various Linux (Ubuntu, Fedora, etc.) and Unix distributions (Mac OS X, BSD, etc.). Please refer to the installation procedure.
If you only need the Python bindings of Pinocchio, you may prefer to install it through Conda. Please follow the procedure described here.
ROS
Pinocchio is also deployed on ROS. You may follow its deployment status below.
If you’re interested in using Pinocchio on systems and/or with packages that integrate with the ROS ecosystem, we recommend the installation of Pinocchio via the binaries distributed via the ROS PPA. Here, you can install Pinocchio using:
sudo apt install ros-$ROS_DISTRO-pinocchio
This installs Pinocchio with HPP-FCL support and with Python bindings. You can then use Pinocchio in your ROS packages by:
- Depending on Pinocchio in your
package.xml
config (<depend>pinocchio</depend>
) - Including Pinocchio via CMake (
find_package(pinocchio REQUIRED)
) and linking against Pinocchio (target_link_libraries(my_library pinocchio::pinocchio)
)
We include support and hooks to discover the package for both ROS 1 and ROS 2. Examples can be found at the following repositories:
Please note that we always advise including the pinocchio/fwd.hpp
header as the first include to avoid compilation errors from differing Boost-variant sizes.
ROS 1 | ROS 2 | |||
---|---|---|---|---|
Melodic | Foxy | |||
Noetic | Galactic | |||
Humble | ||||
Rolling |
Visualization
Pinocchio provides support for many open-source and free visualizers:
- Gepetto Viewer: a C++ viewer based on OpenSceneGraph with Python bindings and Blender export. See here for a C++ example on mixing Pinocchio and Gepetto Viewer.
- Meshcat: supporting visualization in Python and which can be embedded inside any browser.
- Panda3d: supporting visualization in Python and which can be embedded inside any browser.
- RViz: supporting visualization in Python and which can interact with other ROS packages.
Many external viewers can also be integrated. For more information, see the example here.
Citing Pinocchio
To cite Pinocchio in your academic research, please consider citing the software paper and use the following BibTeX entry:
@inproceedings{carpentier2019pinocchio,
title={The Pinocchio C++ library -- A fast and flexible implementation of rigid body dynamics algorithms and their analytical derivatives},
author={Carpentier, Justin and Saurel, Guilhem and Buondonno, Gabriele and Mirabel, Joseph and Lamiraux, Florent and Stasse, Olivier and Mansard, Nicolas},
booktitle={IEEE International Symposium on System Integrations (SII)},
year={2019}
}
And the following one for the link to the GitHub codebase:
@misc{pinocchioweb,
author = {Justin Carpentier and Florian Valenza and Nicolas Mansard and others},
title = {Pinocchio: fast forward and inverse dynamics for poly-articulated systems},
howpublished = {https://stack-of-tasks.github.io/pinocchio},
year = {2015--2021}
}
Citing specific algorithmic contributions
Pinocchio goes beyond implementing the standard rigid-body dynamics algorithms and results from active research on simulation, learning and control. Pinocchio provides state-of-the-art algorithms for handling constraints, differentiating forward and inverse dynamics, etc. If you use these algorithms, please consider citing them in your research articles.
- Le Lidec, Q., Montaut, L. & Carpentier, J. (2024, July). From Compliant to Rigid Contact Simulation: a Unified and Efficient Approach. In RSS 2024-Robotics: Science and Systems.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2024). GJK++: Leveraging Acceleration Methods for Faster Collision Detection. IEEE Transactions on Robotics.
- Sathya, A., & Carpentier, J. (2024). Constrained Articulated Body Dynamics Algorithms. Under review.
- Montaut, L., Le Lidec, Q., Bambade, A., Petrik, V., Sivic, J., & Carpentier, J. (2023, May). Differentiable collision detection: a randomized smoothing approach. In 2023 IEEE International Conference on Robotics and Automation (ICRA).
- Le Lidec, Q., Jallet, W., Montaut, L., Laptev, I., Schmid, C., & Carpentier, J. (2023). Contact models in robotics: a comparative analysis. Under review.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2022, June). Collision Detection Accelerated: An Optimization Perspective. In Robotics: Science and Systems (RSS 2O22).
- Carpentier, J., Budhiraja, R., & Mansard, N. (2021, July). Proximal and sparse resolution of constrained dynamic equations. In Robotics: Science and Systems (RSS 2021).
- Carpentier, J., & Mansard, N. (2018, June). Analytical derivatives of rigid body dynamics algorithms. In Robotics: Science and systems (RSS 2018).
Questions and Issues
Do you have a question or an issue? You may either directly open a new question or a new issue or, directly contact us via the mailing list pinocchio@inria.fr.
Credits
The following people have been involved in the development of Pinocchio and are warmly thanked for their contributions:
- Justin Carpentier (Inria): main developer and manager of the project
- Nicolas Mansard (LAAS-CNRS): initial project instructor
- Guilhem Saurel (LAAS-CNRS): continuous integration and deployment
- Joseph Mirabel (Eureka Robotics): Lie groups and hpp-fcl implementation
- Antonio El Khoury (Wandercraft): bug fixes
- Gabriele Buondono (LAAS-CNRS): features extension, bug fixes, and Python bindings
- Florian Valenza (Astek): core developments and hpp-fcl support
- Wolfgang Merkt (University of Oxford): ROS integration and support
- Rohan Budhiraja (LAAS-CNRS): features extension
- Loïc Estève (Inria): Conda integration and support
- Igor Kalevatykh (Inria): Panda3d viewer support
- Matthieu Vigne (Wandercraft): MeshCat viewer support
- Robin Strudel (Inria): features extension
- François Keith (CEA): Windows support
- Sarah El Kazdadi (Inria): multi-precision arithmetic support
- Nicolas Torres Alberto (Inria): features extension
- Etienne Arlaud (Inria): RViz viewer support
- Wilson Jallet (LAAS-CNRS/Inria): extension of Python bindings
- Fabian Schramm (Inria): core developper
- Shubham Singh (UT Austin): second-order inverse dynamics derivatives
- Stéphane Caron (Inria): core developper
- Joris Vaillant (Inria): core developer and manager of the project
- Sebastian Castro (The AI Institute): MeshCat viewer feature extension
- Lev Kozlov: Kinetic and potential energy regressors
- Megane Millan (Inria): Features extension and core developer
- Simeon Nedelchev: Pseudo inertia and Log-cholesky parametrization
If you have participated in the development of Pinocchio, please add your name and contribution to this list.
Open-source projects relying on Pinocchio
- Crocoddyl: A software to realize model predictive control for complex robotics platforms.
- TSID: A software that implements a Task Space Inverse Dynamics QP.
- HPP: A SDK that implements motion planners for humanoids and other robots.
- Jiminy: A simulator based on Pinocchio.
- ocs2: A toolbox for Optimal Control for Switched Systems (OCS2)
- TriFingerSimulation: TriFinger Robot Simulation (a Robot to perform RL on manipulation).
- Casadi_Kin_Dyn: IIT Package for generation of symbolic (SX) expressions of robot kinematics and dynamics.
- PyRoboPlan: An educational Python library for manipulator motion planning using the Pinocchio Python bindings.
- ProxSuite-NLP: A primal-dual augmented Lagrangian solver for nonlinear programming on manifolds.
- Aligator: A versatile and efficient framework for constrained trajectory optimization.
- Simple: The Simple Simulator: Simulation Made Simple.
- LoIK: Low-Complexity Inverse Kinematics.
Acknowledgments
The development of Pinocchio is actively supported by the Gepetto team @LAAS-CNRS and the Willow team @INRIA.
CONTRIBUTING
Contributing Guidelines
Thank you for your interest in contributing to pinocchio
.
Whether it’s a bug report, new feature, correction, or additional
documentation, we greatly value feedback and contributions from our community.
Please read through this document before submitting any issues or pull requests to ensure we have all the necessary information to effectively respond to your bug report or contribution.
Reporting Bugs/Feature Requests
We welcome you to use the GitHub issue tracker to report bugs or suggest features.
When filing an issue, please check [existing open][issues], or [recently closed][closed-issues], issues to make sure somebody else hasn’t already reported the issue. Please try to include as much information as you can. Details like these are incredibly useful:
- A reproducible test case or series of steps
- The version of our code being used
- Any modifications you’ve made relevant to the bug
- Anything unusual about your environment or deployment
Contributing via Pull Requests
The following guidance should be up-to-date, but the documentation as found here should prove as the final say.
Contributions via pull requests are much appreciated. Before sending us a pull request, please ensure that:
- Limited scope. Your PR should do one thing or one set of things. Avoid adding “random fixes” to PRs. Put those on separate PRs.
- Give your PR a descriptive title. Add a short summary, if required.
- Make sure the pipeline is green.
- Don’t be afraid to request reviews from maintainers.
- New code = new tests. If you are adding new functionality, always make sure to add some tests exercising the code and serving as live documentation of your original intention.
To send us a pull request, please:
- Fork the repository.
- Modify the source; please focus on the specific change you are contributing. If you also reformat all the code, it will be hard for us to focus on your change.
- Ensure local tests pass. (
make test
) - Commit to your fork using clear commit messages.
- Send a pull request, answering any default questions in the pull request interface.
- Pay attention to any automated CI failures reported in the pull request, and stay involved in the conversation.
GitHub provides additional documentation on forking a repository and creating a pull request.
Finding contributions to work on
Looking at the existing issues is a great way to find something to contribute on. As this project, by default, uses the default GitHub issue labels (enhancement/bug/duplicate/help wanted/invalid/question/wontfix), looking at any [‘help wanted’][help-wanted] issues is a great place to start.
Licensing
Any contribution that you make to this repository will be under the BSD Clause 2 License, as dictated by that [license]:
BSD 2-Clause License
Copyright (c) 2014-2021, CNRS
Copyright (c) 2018-2021, INRIA
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the Pinocchio project.
Repository Summary
Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
VCS Type | git |
VCS Version | devel |
Last Updated | 2024-10-14 |
Dev Status | DEVELOPED |
CI status | No Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Packages
Name | Version |
---|---|
pinocchio | 3.2.0 |
README
Pinocchio instantiates the state-of-the-art Rigid Body Algorithms for poly-articulated systems based on revisited Roy Featherstone’s algorithms. Besides, Pinocchio provides the analytical derivatives of the main Rigid-Body Algorithms, such as the Recursive Newton-Euler Algorithm or the Articulated-Body Algorithm.
Pinocchio was first tailored for robotics applications, but it can be used in other contexts (biomechanics, computer graphics, vision, etc.). It is built upon Eigen for linear algebra and FCL for collision detection. Pinocchio comes with a Python interface for fast code prototyping, directly accessible through Conda.
Pinocchio is now at the heart of various robotics software as Crocoddyl, an open-source and efficient Differential Dynamic Programming solver for robotics, the Stack-of-Tasks, an open-source and versatile hierarchical controller framework or the Humanoid Path Planner, open-source software for Motion and Manipulation Planning.
If you want to learn more about Pinocchio internal behaviors and main features, we invite you to read the related paper and the online documentation.
If you want to dive into Pinocchio directly, only one single line is sufficient (assuming you have Conda):
conda install pinocchio -c conda-forge
or via pip (currently only available on Linux):
pip install pin
Table of contents
- Table of contents
- Introducing Pinocchio 3
- Pinocchio main features
- Documentation
- Examples
- Tutorials
- Pinocchio continuous integrations
- Performances
- Ongoing developments
- Installation
- Visualization
- Citing Pinocchio
- Questions and Issues
- Credits
- Open-source projects relying on Pinocchio
- Acknowledgments
Introducing Pinocchio 3
Pinocchio3 is the latest major release of Pinocchio. It comes with multiple new features, such as:
- Sparse constrained dynamics and its analytical derivatives
- Full support of closed-loop mechanisms
- State-of-the-art frictional contact solvers
- Low-complexity constrained articulated body algorithms
- Full support of multiple-precision floating-point (MPFR) in Python and C++
- Full CasADi support in Python and C++
- Increased support of CppAD and CppADCodeGen
- New SDF and MJCF parsers
- and much more.
Pinocchio main features
Pinocchio is fast:
- C++ template library,
- cache friendly,
- automatic code generation support is available via CppADCodeGen.
Pinocchio is versatile, implementing basic and more advanced rigid body dynamics algorithms:
- forward kinematics and its analytical derivatives,
- forward/inverse dynamics and their analytical derivatives,
- centroidal dynamics and its analytical derivatives,
- support multiple precision arithmetic via Boost.Multiprecision or any similar framework,
- computations of kinematic and dynamic regressors for system identification and more,
- and much more with the support of modern and open-source Automatic Differentiation frameworks like CppAD or CasADi.
Pinocchio is flexible:
- header only,
- C++ 98/03/11/14/17/20 compliant.
Pinocchio is extensible. Pinocchio is multi-thread friendly. Pinocchio is reliable and extensively tested (unit-tests, simulations, and real-world robotics applications). Pinocchio is supported and tested on Windows, Mac OS X, Unix, and Linux (see build status here).
Documentation
The online Pinocchio documentation of the last release is available here. A cheat sheet pdf with the main functions and algorithms can be found here.
Examples
In the examples directory, we provide some basic examples of using Pinocchio in Python. Additional examples introducing Pinocchio are also available in the documentation.
Tutorials
Pinocchio comes with a large bunch of tutorials aiming at introducing the basic tools for robot control. Tutorial and training documents are listed here. You can also consider the interactive Jupyter notebook set of tutorials developed by Nicolas Mansard and Yann de Mont-Marin.
Pinocchio continuous integrations
Pinocchio is constantly tested for several platforms and distributions, as reported below:
CI on ROS | |
CI on Linux via APT | |
CI on OSX via Conda | |
CI on Windows via Conda | |
CI on Linux via Robotpkg |
Performances
Pinocchio exploits, at best, the sparsity induced by the kinematic tree of robotics systems. Thanks to modern programming language paradigms, Pinocchio can unroll most of the computations directly at compile time, allowing to achieve impressive performances for a large range of robots, as illustrated by the plot below, obtained on a standard laptop equipped with an Intel Core i7 CPU @ 2.4 GHz.
For other benchmarks, and mainly the capacity of Pinocchio to exploit, at best, your CPU capacities using advanced code generation techniques, we refer to the technical paper. In addition, the introspection may also help you to understand and compare the performances of the modern rigid body dynamics libraries.
Ongoing developments
If you want to follow the current developments, you can directly refer to the devel branch. The master branch only contains the latest release. Any new Pull Request should then be submitted on the devel branch.
Installation
Pinocchio can be easily installed on various Linux (Ubuntu, Fedora, etc.) and Unix distributions (Mac OS X, BSD, etc.). Please refer to the installation procedure.
If you only need the Python bindings of Pinocchio, you may prefer to install it through Conda. Please follow the procedure described here.
ROS
Pinocchio is also deployed on ROS. You may follow its deployment status below.
If you’re interested in using Pinocchio on systems and/or with packages that integrate with the ROS ecosystem, we recommend the installation of Pinocchio via the binaries distributed via the ROS PPA. Here, you can install Pinocchio using:
sudo apt install ros-$ROS_DISTRO-pinocchio
This installs Pinocchio with HPP-FCL support and with Python bindings. You can then use Pinocchio in your ROS packages by:
- Depending on Pinocchio in your
package.xml
config (<depend>pinocchio</depend>
) - Including Pinocchio via CMake (
find_package(pinocchio REQUIRED)
) and linking against Pinocchio (target_link_libraries(my_library pinocchio::pinocchio)
)
We include support and hooks to discover the package for both ROS 1 and ROS 2. Examples can be found at the following repositories:
Please note that we always advise including the pinocchio/fwd.hpp
header as the first include to avoid compilation errors from differing Boost-variant sizes.
ROS 1 | ROS 2 | |||
---|---|---|---|---|
Melodic | Foxy | |||
Noetic | Galactic | |||
Humble | ||||
Rolling |
Visualization
Pinocchio provides support for many open-source and free visualizers:
- Gepetto Viewer: a C++ viewer based on OpenSceneGraph with Python bindings and Blender export. See here for a C++ example on mixing Pinocchio and Gepetto Viewer.
- Meshcat: supporting visualization in Python and which can be embedded inside any browser.
- Panda3d: supporting visualization in Python and which can be embedded inside any browser.
- RViz: supporting visualization in Python and which can interact with other ROS packages.
Many external viewers can also be integrated. For more information, see the example here.
Citing Pinocchio
To cite Pinocchio in your academic research, please consider citing the software paper and use the following BibTeX entry:
@inproceedings{carpentier2019pinocchio,
title={The Pinocchio C++ library -- A fast and flexible implementation of rigid body dynamics algorithms and their analytical derivatives},
author={Carpentier, Justin and Saurel, Guilhem and Buondonno, Gabriele and Mirabel, Joseph and Lamiraux, Florent and Stasse, Olivier and Mansard, Nicolas},
booktitle={IEEE International Symposium on System Integrations (SII)},
year={2019}
}
And the following one for the link to the GitHub codebase:
@misc{pinocchioweb,
author = {Justin Carpentier and Florian Valenza and Nicolas Mansard and others},
title = {Pinocchio: fast forward and inverse dynamics for poly-articulated systems},
howpublished = {https://stack-of-tasks.github.io/pinocchio},
year = {2015--2021}
}
Citing specific algorithmic contributions
Pinocchio goes beyond implementing the standard rigid-body dynamics algorithms and results from active research on simulation, learning and control. Pinocchio provides state-of-the-art algorithms for handling constraints, differentiating forward and inverse dynamics, etc. If you use these algorithms, please consider citing them in your research articles.
- Le Lidec, Q., Montaut, L. & Carpentier, J. (2024, July). From Compliant to Rigid Contact Simulation: a Unified and Efficient Approach. In RSS 2024-Robotics: Science and Systems.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2024). GJK++: Leveraging Acceleration Methods for Faster Collision Detection. IEEE Transactions on Robotics.
- Sathya, A., & Carpentier, J. (2024). Constrained Articulated Body Dynamics Algorithms. Under review.
- Montaut, L., Le Lidec, Q., Bambade, A., Petrik, V., Sivic, J., & Carpentier, J. (2023, May). Differentiable collision detection: a randomized smoothing approach. In 2023 IEEE International Conference on Robotics and Automation (ICRA).
- Le Lidec, Q., Jallet, W., Montaut, L., Laptev, I., Schmid, C., & Carpentier, J. (2023). Contact models in robotics: a comparative analysis. Under review.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2022, June). Collision Detection Accelerated: An Optimization Perspective. In Robotics: Science and Systems (RSS 2O22).
- Carpentier, J., Budhiraja, R., & Mansard, N. (2021, July). Proximal and sparse resolution of constrained dynamic equations. In Robotics: Science and Systems (RSS 2021).
- Carpentier, J., & Mansard, N. (2018, June). Analytical derivatives of rigid body dynamics algorithms. In Robotics: Science and systems (RSS 2018).
Questions and Issues
Do you have a question or an issue? You may either directly open a new question or a new issue or, directly contact us via the mailing list pinocchio@inria.fr.
Credits
The following people have been involved in the development of Pinocchio and are warmly thanked for their contributions:
- Justin Carpentier (Inria): main developer and manager of the project
- Nicolas Mansard (LAAS-CNRS): initial project instructor
- Guilhem Saurel (LAAS-CNRS): continuous integration and deployment
- Joseph Mirabel (Eureka Robotics): Lie groups and hpp-fcl implementation
- Antonio El Khoury (Wandercraft): bug fixes
- Gabriele Buondono (LAAS-CNRS): features extension, bug fixes, and Python bindings
- Florian Valenza (Astek): core developments and hpp-fcl support
- Wolfgang Merkt (University of Oxford): ROS integration and support
- Rohan Budhiraja (LAAS-CNRS): features extension
- Loïc Estève (Inria): Conda integration and support
- Igor Kalevatykh (Inria): Panda3d viewer support
- Matthieu Vigne (Wandercraft): MeshCat viewer support
- Robin Strudel (Inria): features extension
- François Keith (CEA): Windows support
- Sarah El Kazdadi (Inria): multi-precision arithmetic support
- Nicolas Torres Alberto (Inria): features extension
- Etienne Arlaud (Inria): RViz viewer support
- Wilson Jallet (LAAS-CNRS/Inria): extension of Python bindings
- Fabian Schramm (Inria): core developper
- Shubham Singh (UT Austin): second-order inverse dynamics derivatives
- Stéphane Caron (Inria): core developper
- Joris Vaillant (Inria): core developer and manager of the project
- Sebastian Castro (The AI Institute): MeshCat viewer feature extension
- Lev Kozlov: Kinetic and potential energy regressors
- Megane Millan (Inria): Features extension and core developer
- Simeon Nedelchev: Pseudo inertia and Log-cholesky parametrization
If you have participated in the development of Pinocchio, please add your name and contribution to this list.
Open-source projects relying on Pinocchio
- Crocoddyl: A software to realize model predictive control for complex robotics platforms.
- TSID: A software that implements a Task Space Inverse Dynamics QP.
- HPP: A SDK that implements motion planners for humanoids and other robots.
- Jiminy: A simulator based on Pinocchio.
- ocs2: A toolbox for Optimal Control for Switched Systems (OCS2)
- TriFingerSimulation: TriFinger Robot Simulation (a Robot to perform RL on manipulation).
- Casadi_Kin_Dyn: IIT Package for generation of symbolic (SX) expressions of robot kinematics and dynamics.
- PyRoboPlan: An educational Python library for manipulator motion planning using the Pinocchio Python bindings.
- ProxSuite-NLP: A primal-dual augmented Lagrangian solver for nonlinear programming on manifolds.
- Aligator: A versatile and efficient framework for constrained trajectory optimization.
- Simple: The Simple Simulator: Simulation Made Simple.
- LoIK: Low-Complexity Inverse Kinematics.
Acknowledgments
The development of Pinocchio is actively supported by the Gepetto team @LAAS-CNRS and the Willow team @INRIA.
CONTRIBUTING
Contributing Guidelines
Thank you for your interest in contributing to pinocchio
.
Whether it’s a bug report, new feature, correction, or additional
documentation, we greatly value feedback and contributions from our community.
Please read through this document before submitting any issues or pull requests to ensure we have all the necessary information to effectively respond to your bug report or contribution.
Reporting Bugs/Feature Requests
We welcome you to use the GitHub issue tracker to report bugs or suggest features.
When filing an issue, please check [existing open][issues], or [recently closed][closed-issues], issues to make sure somebody else hasn’t already reported the issue. Please try to include as much information as you can. Details like these are incredibly useful:
- A reproducible test case or series of steps
- The version of our code being used
- Any modifications you’ve made relevant to the bug
- Anything unusual about your environment or deployment
Contributing via Pull Requests
The following guidance should be up-to-date, but the documentation as found here should prove as the final say.
Contributions via pull requests are much appreciated. Before sending us a pull request, please ensure that:
- Limited scope. Your PR should do one thing or one set of things. Avoid adding “random fixes” to PRs. Put those on separate PRs.
- Give your PR a descriptive title. Add a short summary, if required.
- Make sure the pipeline is green.
- Don’t be afraid to request reviews from maintainers.
- New code = new tests. If you are adding new functionality, always make sure to add some tests exercising the code and serving as live documentation of your original intention.
To send us a pull request, please:
- Fork the repository.
- Modify the source; please focus on the specific change you are contributing. If you also reformat all the code, it will be hard for us to focus on your change.
- Ensure local tests pass. (
make test
) - Commit to your fork using clear commit messages.
- Send a pull request, answering any default questions in the pull request interface.
- Pay attention to any automated CI failures reported in the pull request, and stay involved in the conversation.
GitHub provides additional documentation on forking a repository and creating a pull request.
Finding contributions to work on
Looking at the existing issues is a great way to find something to contribute on. As this project, by default, uses the default GitHub issue labels (enhancement/bug/duplicate/help wanted/invalid/question/wontfix), looking at any [‘help wanted’][help-wanted] issues is a great place to start.
Licensing
Any contribution that you make to this repository will be under the BSD Clause 2 License, as dictated by that [license]:
BSD 2-Clause License
Copyright (c) 2014-2021, CNRS
Copyright (c) 2018-2021, INRIA
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the Pinocchio project.