What GraspIt! is¶
GraspIt! was created to serve as a tool for grasping research. It is a simulator that can accommodate arbitrary hand and robot designs. It can also load objects and obstacles of arbitrary geometry to populate a complete simulation world. The GraspIt! engine includes a rapid collision detection and contact determination system that allows a user to interactively manipulate a robot or an object and create contacts between them. Once a grasp is created, one of the key features of the simulator is the set of grasp quality metrics. Each grasp is evaluated with numeric quality measures, and visualization methods allow the user to see the weak point of the grasp and create arbitrary 3D projections of the 6D grasp wrench space.
In our experience, we have found that GraspIt! usually serves one of two purposes. First, it can be used as a development tool, to execute and test various robot control algorithms. In this sense, it serves as a replacement for the real world: in simulation, an algorithm can be tested on many hand designs, many objects and obstacle configurations, at no cost and much faster than in the real world. Second, GraspIt! can be used as a computational platform that backs up a robot that does operate in the real world. For example, a real robot can acquire a model of a target object, then use GraspIt! to quickly evaluate multiple grasping or manipulation scenarios. Often, these scenarios are also combined and the same GraspIt! setup used for development of an algorithm can also be used for computations during real life execution.
GraspIt! has many features that help accomplish these roles; all of these features are documented in the second part of this manual. The most commonly used include the contact detection and grasp quality metrics mentioned above, the dynamics engine and the grasp planning capabilities. The dynamics engine within GraspIt! computes the motions of a group of connected robot elements, such as an arm and a hand, under the influence of controlled motor forces, joint constraint forces, contact forces and external forces. This allows a user to dynamically simulate an entire grasping task, as well as test custom robot control algorithms. The grasp planning algorithms rely on the simulated environment to quickly evaluate many hand postures, and find those that lead to stable grasps. There are many possible implementations of this concept; the planners that are included with GraspIt! can usually find multiple stable grasps of an object in less than 1 minute, taking into account obstacles and other constraints.
Overall, GraspIt! is an open-source virtual environment for simulating robotic grasping tasks accompanied by a number of analysis and development tools. It has been developed in C++ using many other open-source libraries, and is cross-platform, tested on both Windows and Ubuntu Linux.
What GraspIt! is NOT¶
GraspIt! is not an off-the-shelf product. It is rather a large codebase that is the result of many years of research and development in the Robotics Lab at Columbia University. The tools included can greatly help in the development and testing of new algorithms and approaches. However, we have often found that most new interesting problems can not be completely addressed by applying these tools exactly as they are. It is very possible that, in the process, you will find yourself needing various changes or additions to the simulator; these might be bigger or smaller depending on your problem. This means that you might have to get your hands dirty and tinker with the code itself, which we encourage you to do. We have done our best to create clean, robust and well-documented code. However, we are not a large team of product development software engineers; rather, we are a small group of robotics researchers. As a result, do not be surprised if you find parts of the code that can be improved.
About this manual¶
This manual is divided into two parts. The first one, containing Chapters 1 through 4, is an introduction to the GraspIt! environment, covering the essential aspects for loading and populating a GraspIt! world and interacting with it. The references to the source code are kept at a minimum. In the second part, containing Chapters 5 through 17, we discuss the GraspIt! advanced features, or the tools that it offers for solving various problems. Here we overlap discussions of the simulator as a final product with discussion of the source code itself. We also introduce a number of features of GraspIt! that are not completely finished yet, and might not be very robust, but have been included in the distribution in the hope you might find them useful. Such features will be marked by the qualifier “Under Development” - only use them if you’re not afraid of delving inside the code to get the most out of them and fix an occasional bug.
Please note that, much like the code itself, this manual is under continuous development. There are many aspects that it does not touch at all, or explains too briefly. If there is a topic that you found particularly confusing, or you would like to see expanded, we would appreciate your feedback.
Troubleshooting and contact¶
GraspIt! includes two main resources: this manual, and a complete code
reference. We have put a lot of work into both of them, and we strongly
encourage you to try using them to solve your problem before contacting
us. If that fails, we will try to provide support via email; write us at
firstname.lastname@example.org. General comments on the simulator,
and any patches or improvements to the code are always appreciated.