Simox is a lightweight platform independent C++ toolbox containing three libraries for 3D simulation of robot systems, sampling based motion planning and grasp planning. The Virtual Robot library is used to define complex robot systems which may cover multiple robots with many degrees of freedom. The robot structure and its visualization can be easily defined via XML files and environments with obstacles and objects to manipulate are supported. The libraries Grasp Studio and Saba use these definitions for planning grasps or collision-free motions. State-of-the-art implementations of sampling-based motion planning algorithms (e.g. Rapidly-exploring Random Trees) are served by the Saba library which was designed for efficient planning in high-dimensional configuration spaces. The library Grasp Studio offers possibilities to compute grasp quality scores for generic end-effector definitions (e.g. a humanoid hand). The implemented 6D wrench-space computations, offer the possibility to easily (and quickly) measure the quality of an applied grasp to an object. Furthermore, the implemented planners are able to generate grasp maps for given objects automatically.
The wiki pages offer installation, first-steps support and documentation:
With the Virtual Robot library robots and environments can be specified and accessed via XML definitions. The structure of a robot is given by its joints (called RobotNodes) which are defined via Denavit-Hartenberg conventions or an easy-to-use “Translation+Rotation” scheme. The robot specification holds further information as name, joint limits, sensors, visualization and collision models. For convenient access kinematic chains and collections of collision models can be additionally defined. An instance of such a robot definition can be visualized by a viewer to show the current state of a robot. Furthermore, environments, obstacles and objects to manipulate can be defined and visualized. Thus it is possible to construct complex scenes used for simulation or planning and to store and load such scene definitions to/from XML files. The main features of the library are:
- The library defines an interface for collision checking, allowing to exchange the collision checker used for determining distances or collisions. Currently the PQP collision checker is used due to its fast and robust implementation.
- A generic computation of Jacobians and their Pseudoinverse are offered for arbitrary kinematic chains.
- A generic IK solver, utilizing randomized approaches, is implemented for solving the IK for redundant kinematic chains.
- Reachability distributions are supported, in order to precompute the 6D reachability of a kinematic structure (e.g. an arm) and to quickly decide whether a pose in workspace is reachable or not.
- A generic definition of end effectors allows to realize complex hands (e.g. humanoid hands can be defined). End effectors can be opened/closed and contact information can be retrieved e.g. for grasp scoring.
- It is possible to store and load object-related grasping information for a given end-effector, which directly can be used within the IK solvers.
- Multithreading is supported, e.g. multiple instances of the collision checker can be used to parallelize collision queries.
The Sampling Based Motion Planning Library is designed to efficiently compute collision-free motions for redundant robot systems with many degrees of freedom. The algorithms provided are based on Rapidly-exploring Random Trees (RRT), which allow a quick sampling of the collision-free configuration space. Several planners, starting with the basic RRT-Connect planner, are implemented and a lot of tools e.g. for path smoothing or visualization are provided. The main features are:
- To manage multiple collision checks (e.g. between different parts of a robot, between multiple robots and/or obstacles), the CollisionCheckingManagement (CCM) class provides an intuitive way of defining a set of collision models for which mutual collisions should be checked.
- Classes for handling configuration spaces can be configured depending on the demands (e.g. CCMs and sampling / collision checking step size can be specified). The commonly used class CSpaceSampled offers methods for determining whether a single configuration or a complete path is in C-Free or not. Efficient implementations for path checking are given, i.e. recursive divide-and-conquer algorithms for efficient collision testing of C-space paths.
- The basic RRT-based algorithms are implemented, RRT-Extend, RRT-Connect and BiRRT with some variants. Additionally more sophisticated planners (e.g. Goal-Sampling RRTs as the IK-RRT or the Bimanual IK-RRT, planners considering constraints, planners doing a multi-threaded search and planners giving guarantees with FreeBubbles) are provided.
- Methods to visualize RRTs, solution paths or CSpaces are included.
- Path-Optimizations can be done either with elastic band approaches or by searching shortcuts in C-space.
- Multi-threading support: Each planner and each path optimizer can be started in a thread.
The Grasp Studio library contains methods and tools used for measuring grasp qualities. Therefore an interface to the qhull library is provided to build convex hulls in 3D or 6D. The methods for measuring grasp qualities implement methods based on force-space related algorithms in 3D and a full implementation of 6D grasp wrench spaces is included. Grasping setups of simple end-effectors, multi-finger hands, multi-hand and multi-robot grasps can be evaluated by the Grasp Studio library. Grasp planners are implemented for building object specific grasp maps for given end-effectors.