Pin

Summary

The main modifications concern the update of the code to comply with the Humanoid Path Planner (HPP).

This release is directly accessible as a Debian package. Please see https://github.com/stack-of-tasks/pinocchio/wiki/installation for further details.

New Features
- Add Joint{Model,Data} classes based on Joint{Model,Data}Base and Joint{Model,Data}Variant. Those classes call directly the visitors and make Variant accessible throw methods
- Add partial Joint{Model,Data}Composite. They allow a stack of joints without adding any Inertia.
- Increase Frame class. Frames can be of several types (BODY, JOINT, SENSOR, etc) and reflect the robot tree as it appears in the URDF conventions. Frames have two attributes: parent which the direct Joint parent in the Joint tree, previousFrame which correspond to the parent Frame in the tree of Frames).
- Adding Python parser which is able to read models written in Python.
- Add algo checker to check the validity of a model.
- Improve documentation.

API modifications
- Model has some methods deprecated. The default name has been removed.
- The Geometry classes have been updated and several methods have been set to deprecated. They now use Frames as parent instead of Joint directly: a Geometry is now supported by a BODY.
- Add active collision pair flags in GeomData which define the active collision pairs.
- Unify naming conventions (nframes, njoints, etc).

Fixes
- The UDRF parser can now deal with more complex topologies. It properly handles the stack of geometries for each BODY.
- Improve packaging mainly around the Python part.

Summary

This release is directly accessible as a Debian package. Please see https://github.com/stack-of-tasks/pinocchio/wiki/installation for further details.

New Features
- Added operational frames (that are a Plucker coordinate frame attached to a parent joint inside a kinematic tree). Position and Jacobian of such frames can be computed
- Geometry primitives can now be handled (and added to the Pinocchio GeometryModel) when encountered in an urdf file
- Implemented simple srdf parsing for GeometryData : parse the desactivated collision pairs
- Added Articulated Body Algorithm (ABA), and CCRBA
- When parsing a urdf file, now look in the environment variable ROS_PACKAGE_PATH for directories where to search for meshes. Users can provide hint directories to search in as a priority. Updated python RobotWrapper consequently
- Added forward dynamics with contact algorithm
- Added algorithms working with vectors of configuration or velocity(either on a JointModel or on a Model, iterating through all the kinematic tree)
- One can integrate a configuration at a constant velocity during a unit time
- One can differentiate two configurations (i.e compute the velocity that must be integrated during a unit time to go from first configuration to the other )
- One can interpolate between two configurations
- One cancompute the distance between two configurations ( such as dist = norm ( difference) )
- One can shoot a configuration uniformly sampled between specified limits
- Added Impulse Dynamic Algorithm
- Completed the list of method to access or call Joint's data or method when joint are stored in a variant.
- Added JointAccessor that is a general joint encapsulating a JointVariant ( abstracting the use of visitors for the user).

API modifications
- Moved limits from joint models to Model as vectors of size nq for position limits and size nv for velocity and effort limits
- The Geometry objects stored in GeometryModel are now splitted in two types : visual and collision

Minor
- Improved documentation of Data, Model, Spatial Classes
- Improved efficiency when executing algorithms
- One can now create Inertia for simple shapes such as cylinders, boxes, ellipsoid
- Rework some unittests to increase to coverage of whole package ( C++ and Python )

Bugs Fixed
- Fixed operator Inertia x constraint in JointSphericalZYX
- Fixed the Dense conversion of joints (models and datas)
Fixed bugs in JointRevoluteUnaligned and JointPrismaticUnaligned to access the access when visiting a variant containing such joints with boost::fusion

Summary

New Features
- Spatial classes now follow the CRTP Design Pattern, for performance reasons.
- JointModels are now exposed in Python. This feature enables one to load a URDF model with a precise root joint and to create his/her own model.
- Python models can now be created by hand ( ex: buildEmptyModel() + calls to addBody() )
- Added utility tools to check an urdf model ( same as check_urdf but dislpay the Pinocchio model created from urdf parsing)
- Add unaligned prismatic joint
- Add geometry through Flexible Collision Library ([hpp-fcl](https://github.com/humanoid-path-planner/hpp-fcl))
- Add dedicated structs to handle geometry. GeometryModel (list of geometry objects and its relation wrt kinematic model) and GeometryData
- When parsing urdf, meshes can be read from collada files and handled in Pinocchio
- Created parser that handles geometry and exposed it in python
- Add algorithms to update the geometry kinematics, to compute the distances for pairs of collision or if they are colliding or not.
- Added algorithms to compute the kinetic energy, the potential energy and exposed it in python
- The complete documentation is in progress

API modifications
- Change name of kinematics algorithms: now forwardKinematics instead of previous geometry, kinematics and dynamics.

Minor
- SimpleHumanoid is now built with joint limits
- Handle floating joints in urdf parsing
- Slight separation between joints and body in Model to avoid confusion
- Internally, Motion and Force classes now use a 6D-vector instead of two 3D-vectors for linear and angular part

Bugs Fixed
- Fixed a bug when trying to merge a link with its parent in case of fixed joint. Now merge only if it has an inertial tag.
- All the algorithms are now set to inline
- Fix compilation errors

Installation

The source of the release are available in the file **pinocchio-1.1.0.tar.gz** just below along with a binary version for 64-bits Debian architecture of Pinocchio **pinocchio_1.1.0_amd64.deb** and its dependencies. For information, those packages will be installed in _/opt/openrobots_ directory.

Summary

New Features
- The limits in position, velocity and torque for joints Revolute and Prismatic are now parsed from urdf model and accessible
- Implementation of exp and log functions on SE3 in C++ with its python binding thanks to aelkhour
- Data now contains information relative to the center of mass position, velocity and acceleration
- Add Lua parser - compatible with RBDL
- Add translational joint
- Add planar joint

Minor
- Reduction of compilation warnings.

Bugs Fixed
- Fixed bug in operator Y*S in JointRevoluteUnaligned

The following algorithms are implemented.
• Recursive Newton-Euler algorithm (RNEA, i.e inverse dynamics)
• Composite Rigid Body algorithm (CRBA, i.e generalized inertia matrix)
• Sparse Cholesky decomposition of the inertia matrix (for constrained forward-dynamics resolution)
• Placement Jacobians (i.e application from configuration velocities to end-effector spatial velocities), along with computation of body placements, velocities and accelerations.
• Center of mass and its Jacobian

The model can either be parsed from a URDF format or be created by appendending bodies. The following joint models are implemented.
• Revolute X, Y, Z (optimized) and unaligned with Cartesian directions
• Prismatic X, Y, Z
• Spherical (with and withoug singularities)
• FreeFlyer (i.e. no constraint, for mobile robots like humanoids -- using quaternion representation for the rotation)
• Fixed (concatenation of two consecutive bodies)