OpenGRASP: A New Robot Grasping Simulation Toolkit

Beatriz León, Gustavo Puche, Higinio Martí, Antonio MoralesUniversitat Jaume I, Castellón, Spain

Steffan Ulbrich, Tamim AsfourKarlsruhe Institute of Technology, Germany

Rosen Diankov, James KuffnerCarnegie Mellon University, Pitssburgh, USA

Sami MoisioLappeenranta University of Technology, Finland

Abstract— Simulation is essential for different robotic re-search fields such as mobile robotics, motion planning and graspplanning. For grasping in particular, there are no softwaresimulation packages, which provide a holistic environmentthat can deal with the variety of aspects associated with thisproblem. These aspects include development and testing ofnew algorithms, modeling of the environments and robots,including the modeling of actuators, sensors and contacts. Inthis paper, we present a new simulation toolkit for grasping anddexterous manipulation called OpenGRASP addressing thoseaspects in addition to extensibility, interoperability and publicavailability. OpenGRASP is based on a modular architecture,that supports the creation and addition of new functionalityand the integration of existing and widely-used technologies andstandards. In addition, a designated editor has been created forthe generation and migration of such models.

Index Terms— software toolkit, grasping simulation, robotmodeling

I. INTRODUCTION AND RELATED WORK

Robot simulators have accompanied robotics for a longtime and have been an essential tool for the design andprogramming of industrial robots. Almost all industrial ma-nipulator manufacturers offer simulation packages accompa-nying their robotic products. These tools allow the usersto program and test their applications without using thereal hardware or even building it since such tools allowthe analysis of behaviours and performance beforehand. Inrobotics research, simulators have an important role in thedevelopment and demonstration of algorithms and techniquesin areas such as path planning, grasp planning, mobilerobot navigation, and others. There are several reasons forthe use of robot simulations. First, they allow exhaustivetesting and tuning of mechanisms and algorithms undervarying environmental conditions. Second, they avoid theuse, or misuse, and wearing of complex and expensive robotsystems. Finally, simulation software is cheaper than realhardware.

Often, simulation tools used to support research are specif-ically developed for particular experiments. However, there

have been some successful attempts to develop general robotsimulators specifically for mobile robotics.

Stage and Gazebo are respectively 2D and 3D simulatorback-ends for Player [1], [4], which is a widely used freesoftware robot interface. Gazebo [2] in particular, imple-ments a 3D multi-robot simulator which includes dynam-ics for outdoor environments. It implements several robotmodels, actuators and sensors. USARSim [5] has a similarfunctionality. It is a free mobile robot simulator based on agaming engine. Microsoft provides its Robotics Studio [3],a framework for robot programming that includes a visualsimulation environment. OpenHRP [7] is an open softwareplatform with various modules for humanoid robot systemssuch as a dynamics simulator, a view simulator, motioncontrollers and motion planners. OpenHRP is integratedwith CORBA, with each module, including the dynamicssimulator implemented as a CORBA server. Commercialoptions include Webots [6], a product which has been widelysuccessful in educational settings.

The variety of simulation tools for robotic grasping israther limited. The most renowned and prominent one isGraspIt!, a grasping simulation environment [9]. GraspIt! in-cludes models of several popular robot hands, implements thedynamics of contacting bodies, includes a grasp planner fora Barrett hand and has recently included a simple model ofthe human hand. However, GraspIt! has several limitations.Its rather monolithic and less modular architecture makesit difficult to improve, add functionality and integrate withother tools and frameworks. In addition, it does not provide aconvenient Application Programming Interface (API), whichallows script programming. Furthermore, it does not includesensor simulation.

Another existing and publicly available software frame-work is OpenRAVE, the Open Robotics and AnimationVirtual Environment [10]. It has been designed as an openarchitecture targeting a simple integration of simulation, vi-sualization, planning, scripting and control of robot systems.It has a modular design, which allows its extension and

further development by other users. Regarding robot graspingsimulation, it provides similar functionality to GraspIt! andvarious path planning components. It provides the modelsof several robot arms and hands and allows the integrationof new ones. It also enables the development of virtualcontrollers for such models.

In this paper we introduce a simulation toolkit specificallyfocused on robot grasping and manipulation. The principaldesign issues have been extensibility, interoperability andpublic availability (see Sec. II). The core of the toolkit is animproved version of OpenRAVE, which has been enhancedwith a Robot Editor and the adoption of the COLLADAfile format [13] and Physics Abstraction Layer (PAL[11] andFISICAS[12]) to enable standardization and flexibility (seeSec. III).

This work is the result of a team funded by the EuropeanCommission within the project GRASP [19]. Within theproject the toolkit is used as the main tool for reasoningand prediction of object properties as well as task constraintsof manipulation and grasping activities executed by robots.Thus, it is a key tool for constructing a world model andunderstanding the robot environment.

II. REQUIREMENTS FOR A GRASP SIMULATOR

From a scientific point of view, a novel simulator for robotgrasping should provide primarily a realistic simulation ofdynamic properties of, at least, rigid objects and advancedcontact models including soft contacts and deformable sur-faces. From a practical and user point of view, it shouldinclude the models of the most popular robot hands, andprovide the possibility of easily creating and adding newones. Furthermore, it should provide realistic simulations ofreal actuators and sensors, which would enable the use of thesame API as in their real counterparts. Regarding sensors,a grasping simulator has to provide simulations of specificgrasping sensors, such as force/torque, contact and tactile.Finally, it should provide a rich and detailed visualization ofsimulations.

With respect to software engineering, a novel robot grasp-ing simulator must be implemented in a modular way thatenables on the one hand, an easy extension by both de-velopers and users and on the other hand, the integrationwith commonly-used robotics software frameworks. In orderto increase its opportunities of being adopted and usedin the scientific community, the simulator should be opensource and make use of open standards for file formats andother representations. In addition, the simulator should haveappropriate tools to import/export robot and object modelsto/from standard representations.

To our best knowledge, none of the existing simulationtools and software packages fulfill all of these requirements.Therefore, we present a software toolkit for grasping simu-lation OpenGRASP [8], which is built on top of OpenRAVEto meet the requirements discussed above.

III. TOOLKIT DESCRIPTION

In order to develop a tool that meets the requirementslisted in the previous section, we adopted a basic practical

Fig. 1. OpenRAVE Architecture (Picture reproduced from [20])

principle: Do not reinvent the wheel. This means, first toreview the existing software paying special attention to thosethat already meet part of the requirements and second tomake use of existing open and widely-available softwarepackages and standards.

After a wide review of existing simulators, physics en-gines, 3D render engines, and CAD 3D modelers, we con-cluded that OpenRAVE is the tool that most closely meetsour requirements. So our efforts have focus on improving andextending OpenRAVE capabilities and features towards therealization of an advanced grasping simulator. In addition, wedeveloped a robot editor allowing to create and modify newrobot models. In the following sections we describe theseextensions in more detail.

A. OpenRAVE Architecture

OpenRAVE is a planning architecture developed at theCarnegie Mellon University Robotics Institute. It is designedfor autonomous robot applications and consists of three lay-ers: a core, a plugins layer for interfacing to other libraries,and scripting interfaces for easier access to functions (seeFig.1).

The Scripting Layer enables network scripting environ-ments like Octave, Matlab and Python to communicate withthe core layer in order to control the robot and the environ-ment. It is possible to send commands to change any aspectof the environment, read any of its information, move realrobots, or change physics/collision libraries. The scripts alsoenable the control of multiple OpenRAVE instances acrossthe network, thus allowing different users to independentlysee and interact with the environment.

OpenRAVE is designed as a plugin-based architecture,which allows the creation of new components to continuouslyimprove its original specifications. Each plugin is an imple-mentation of a standard interface that can be loaded dynam-ically without the need to recompile the core. Following thisdesign, different plugins can be created for components suchas sensors, planners, controllers or physics engines. The corelayer communicates with the hardware through the pluginsusing more appropriate robotics packages such as Player andthe Robot Operating System (ROS) [21].

A GUI can be optionally attached to provide a 3D visu-alization of the environment. It periodically queries the coreto update the world’s view and allows the user to change theposition of the objects in the scene. As viewers are providedthrough plugins, a single OpenRAVE instance can allowmultiple viewers to communicate with multiple copies of theenvironment. A more detailed description of the OpenRAVEarchitecture can be found in [10], [20].

Although many plugins are already implemented to pro-vide basic functionality, the current grasp simulation func-tionality has several shortcomings. In order to make Open-RAVE suitable for our purposes, we require:

• Implementation of plugins for specific sensors used toimprove the grasping capabilities of the robot.

• Implementation of more physics engines and collisioncheckers that help to compare and improve simulationperformance.

• Implementation of a standard plugin interface for a basicactuator and implementations of different motors. Thiswould allow us to accurately simulate the robot’s armand hand articulations.

We have taken these considerations into account in ourtoolkit design. We have developed two new sensor pluginsto be used mainly for anthropomorphic robot hands. One isa tactile sensor, commonly used in finger tips such as in theBarrett hand, which detects and calculates the forces on thepredefined sensory area and returns them as an array. Theother is a force sensor, placed for example in the wrist, tomeasure the forces applied while grasping.

Additionally, as models for actuators were not includedin OpenRAVE, we have developed a new sensor type calledST_Actuator. Using this sensor, we implemented new pluginto simulate the motor of the arm and hands joints which canbe controlled using angles, velocities or voltages.

We have created a model of the Schunk PG70 parallel jawgripper using the tactile sensor plugin to simulate the WeissRobotics sensor (DSA 9205) attached to each finger. We havealso provided the Gripper Sensor plugin which returns thedistance between fingers, their current and velocity. Finally,a model of the gripper actuator was also included which cancontrol the velocity of the fingers and the maximum currentapplied.

In order to use different physics engines, we have im-plemented new plugins which makes use of the physicsabstraction layer PAL and FISICAS, which is addressed inmore detail in the following section.

Visualisation is an important part of the simulation. Atthe moment OpenRAVE uses Coin3D/Qt to render the en-vironment, which has several disadvantages. It has recentlychanged its license to GPL which poses a lot of limitationson its distribution and it doesn’t support multi-thread view-ers. Therefore we have created a new viewer plugin usingOpenSceneGraph (OSG) which enable us to provide it withan Apache 2.0 License to be easily used by the OpenRAVEcommunity. OpenSceneGraph [16] is an open source highperformance 3D graphics toolkit, written in c++ and OpenGLwhich can be used in the most common platforms such as

Fig. 2. Screenshot of OpenRAVE using the new osgviewer plugin.

Windows, OSX and GNU/Linux. It allows the use of severalfile formats, specially COLLADA, VRML and IV files.Moreover, it enables the use of multiple threads to visualizedifferent environments simulating concurrent processes inOpenRAVE, like the planning of different trajectories. Asnapshot of the new OSG viewer can be seen in Fig. 2.

B. Physics Simulation

Nowadays, there exist many available physics engines,both commercial and open-source. Some of them are high-precision engines that require higher computational powerwhile others sacrifice this accuracy to work in real time. Themethods they use to simulate physics are also different. Someof them use penalty methods, some rely on physical lawsusing constraint equations, and others use methods based onimpulses.

None of these engines are perfect, they all have advantagesand disadvantages which makes it very difficult to decidewhich one to use for a simulator. It basically depends onwhat we want to simulate in addition to what the applicationof the simulator will be.

In order to simplify this decision, a physics abstractionlayer appears as a solution. It provides an interface to anumber of different physics engines allowing us to dynami-cally switch between them. This functionality adds incredibleflexibility to our simulator offering us the possibility to,depending on our specific environment and use, decide whichengine would provide us the best performance. Using theirinterface, it is also possible test and compare our own engineswith existing ones.

The OpenRAVE Physics Engine interface allows the sim-ulator to run using different engines. It also has an interfaceto implement different collision checkers. Each one of themhas to be created as a plugin, extending either the Physic-sEngineBase or the CollisionCheckerBase class. The basicversion of OpenRAVE only offers the ODE (Open DynamicsEngine) implementation within the oderave plugin.

The Physics Abstraction Layer (PAL) [11], [14] is a

software package created by Adrian Boeing that saves usfrom having to decide at the start what physics engine to use.We have created a new plugin to use PAL, called palrave.This plugin is able to initialize PAL with the specific enginewe want to use, without the need of creating different pluginsfor each one of them.

We have used PAL for a long time, and we have seensome details that make the experience with it unsatisfactory.Its design is chaotic, which makes the code maintenanceand finding possible errors very difficult. Therefore, it isvery hard to add new features or extend the existing ones.Additionally, it seems that there is nobody responsible forits support so often changes are committed without propertesting, which make it very unreliable and unstable.

After analyzing these problems, we decided to developour own physic abstraction layer, FISICAS [12]. This layercomes to solve them, simplifying the design and makingeasy to adapt it to our needs. We have created a pluginFISICASrave to initialize FISICAS with the desired physicengine, supporting currently ODE and Bullet.

C. COLLADA File Format for Robot Models

For the storage of models of robot manipulators and hands,we were looking for an open, extensible and already widelyaccepted file format that supports the definition of at leastkinematics and dynamics. This is necessary in order toenable the exchange of robot models between supportingapplications, leading to greater flexibility in the selection ofappropriate tools. Another important aspect was the abilityto convert to and from other formats. Among the largevariety of file formats for 3D models, there are only a fewthat are both public domain and not limited to storing onlygeometric information. Typically, a simulator environmentdoes not only rely on geometric structures but also, forinstance, on information about dynamics, kinematics, sensorsand actuators of the robot.

Its acceptance as an industry standard and its wide dis-tribution (3D Studio, Blender, OSG, OGRE, Sony, etc.), inaddition to a clear and extensible design, led to the choice ofCOLLADA [13] as the preferred file format for the simulator.In addition, there are open source frameworks available thatfacilitate integration into new applications.

Since version 1.5, the standard contains many usefulconstructs dedicated to describing kinematic chains anddynamics that can be used directly for the description ofrobot models. COLLADA is an XML-based file format thatenables and encourages developers to extend the specificationto their needs without having to violate the underlyingschema definition.

In order to support specific robot features like sensorsand actuators, we have used this mechanism to extendCOLLADA partially using the original OpenRAVE file def-inition. These additions are specific to the simulator and arehidden to all other applications so that compatibility remainsguaranteed. So far, basic support for COLLADA import andexport has been included in the simulator.

D. Robot Editor

With the creation of a simulator for grasping the need alsoarises for a large data base of geometrical, kinematic anddynamic models of robot arms and manipulators. To fill thisgap, the development of a modeling tool, the Robot Editor,has been started. Its main goal is to facilitate modelingand integration of many popular robots. The developmentis driven by the following key aspects:

• Geometric modeling: The creation of new robotsmodels requires a tool that excels in modeling of thegeometric components (i.e., meshes).

• Semantic modeling: Even more important is the abilityto allow the description of semantic properties, such asdefinitions of kinematic chains, sensors and actuators,or even specify algorithms.

• Dynamics modeling: Another necessary aspect is theability to define physical attributes of the robot’s ele-ments. At the moment, the focus lies on the dynamicsof rigid bodies.

• Conversion: Robot models usually come in a varietyof different file formats. The modeling tool needs to becapable of processing these formats and converting theminto the COLLADA standard. GraspIt! files in particu-lar, being an already widely-used standard with manyconform models available, should be readily usable bythe simulator.

To our knowledge, there is no existing solution openly avail-able that could meet all these requirements. Therefore, wedecided to develop a new modeling tool based on availableopen source software. The conceptual design of the RobotEditor hence relies on two techniques: on the one handthe open data format COLLADA and on the other handon the open source project Blender [15]. Blender is a veryversatile, powerful and extensible 3D editor that has beenchosen because of its convenient 3D modeling capabilitiesand the built-in support for many CAD file formats and rigidbody kinematics. Furthermore, it can be easily extended via aPython scripting interface and offers high-quality ray tracing.

Blender itself, however, lacks the functionality and theappropriate interface for the convenient definition of robotcomponents. In addition, conversions between certain fileformats need to be improved or implemented, namely theimport of the COLLADA format and GraspIt! robot models.

The scripting interface mechanism mentioned above al-lowed us to build the modeling tool on top of Blender.On the scripting level, one gains access to all relevantdata structures. The robot model can be augmented by therequired data structures and conserved within the native fileformat. The scripting mechanism also allows the creation ofuser-interface that is highly specialized for use in robotics(see Fig. 3(a)). For instance, you can define kinematicsvia Denavit-Hartenberg parameters. In the long run, theRobot Editor will provide interfaces for essential roboticsalgorithms, such as the computation of dynamics character-istics from the geometric meshes and conversions betweenkinematics representations. Adjacency information of joints

(a)

(b)

Fig. 3. Modeling the Karlsruhe anthropomorphic robot hand. a) The userinterface of the Robot Editor and b) Screenshot of the complete model inthe simulator.

and the impact of joint movements to the robot are additionalcomputational information which, in the future, will be usefulfor developers’ planning algorithms.

In the current Blender version (2.49), COLLADA support[18] is limited to documents in the older specification 1.4which excludes the newly introduced kinematics and dy-namics. The additional data required by the simulator alsoneeds to be included in the resulting document. This led tothe further development of COLLADA compatibility whichnow enables the Robot Editor to create valid documentssuitable for simulation. Fig.3(a) shows a functional modelof the Karlsruhe anthropomorphic hand [17] modified usingthe Robot Editor and Fig.3(b) the resulting COLLADA fileloaded into the simulator .

1) Robot Models: As stated in Section II, it is of greatimportance to have models of the most popular robot handsincluded in the toolkit. The modeling capabilities of theRobot Editor already enable quick and easy creation ofnew models. So far, a selection of robot hands has beentransformed into COLLADA 1.5 for use within the simulator(see Fig. 4). In addition to these new models, there arevarious models available in the older XML file format whichis still supported.

IV. CONCLUSION AND FUTURE WORK

In this paper we have presented a fully operational simu-lation toolkit for robot grasping and manipulation. Its maindesign principles are extensibility, interoperability and publicavailability. In its development we have used existing andwidely-available components to ensure its standardizationand easy adoption. We have also emphasised providingadditional tools and features that provide users with a faststart to enhance utility through features such as the robot

(a) (b)

(c) (d)

(e) (f)

Fig. 4. Different robot models generated with the Robot Editor (ray-tracedimages). (a) A myoelectric upper extremity prostheses of Otto Bock, theSchunk (b)SAH and (c)SDH hands, (d) the Shadow hand, (e) the Barretthand and the Kuka KR5 sixx R850 arm, and (f) the humanoid robotARMAR-III.

editor based on Blender, COLLADA file format, two PhysicsAbstraction Layers (PAL and FISICAS), and models ofexisting robot hands.

In future, we are looking to improve the toolkit in threedirections. First a novel contact modelling for soft contactsand body deformation is being implemented and validated.It will be included as a library to allow the modellingof complex contact interactions. Second, OpenGRASP isbeing extended to offer full support for ROS thus offeringa common control interface for simulated and real robots.Finally, several interfaces are being created in order to offerthe user several options to visualize and record the simulatedsystems.

REFERENCES

[1] Gerkey, B., Vaughan, R., Howard, A.: The Player/Stage Project: Toolsfor Multi-Robot and Distributed Sensor Systems. In: 11th InternationalConference on Advanced Robotics (ICAR 2003), pp. 317–323. Coim-bra, Portugal (2003)

[2] Gazebo, http://playerstage.sourceforge.net/index.php?src=gazebo

[3] Microsoft Robotics Studio, http://msdn.microsoft.com/robotics

[4] The Player Project, http://playerstage.sourceforge.net/wiki/Main\_Page

[5] USARSim, http://sourceforge.net/projects/usarsim/

[6] Webots, http://www.cyberbotics.com/

[7] OpenHRP, http://www.is.aist.go.jp/humanoid/openhrp/

[8] OpenGRASP, http://opengrasp.sourceforge.net/[9] Miller, A., Allen, P.: GraspIt!: A versatile simulator for robotic

grasping. In: IEEE Robotics & Automation Magazine. vol. 11, pp.110–122 (2004)

[10] Diankov, R.: Automated Construction of Robotic Manipulation Pro-grams. Carnegie Mellon University, Robotics Institute, Pittsburgh, PA(2010)

[11] PAL (Physics Abstraction Layer), http://www.adrianboeing.com/pal

[12] FISICAS, http://opengrasp.sourceforge.net/FISICAS.html

[13] COLLADA, http://collada.org[14] Boeing, A., Bräunl, T.: Evaluation of real-time physics simulation

systems. In: 5th international conference on Computer graphics and in-teractive techniques in Australia and Southeast Asia (GRAPHITE’07),pp. 281–288. Perth, Australia (2007)

[15] Blender, http://Blender.org[16] OpenSceneGraph, http://www.openscenegraph.org/[17] Gaiser, I., Schulz, S., Kargov, A., Klosek, H., Bierbaum, A., Py-

latiuk,C., Oberleand, R., Werner, T., Asfour, T., Bretthauer, G.,Dillmann, R.: A new anthropomorphic robotic hand. In: IEEE/RASInternational Conference on Humanoid Robots (Humanoids), pp. 418–422 (2008)

[18] Illusoft: Blender Collada Plugin, http://colladablender.illusoft.com/cms/

[19] GRASP Project, http://www.csc.kth.se/grasp/[20] OpenRAVE, http://openrave.programmingvision.com/[21] ROS, http://www.ros.org/wiki/