Finger design automation for industrial robot grippers: A review <s> Collision Detection <s> we present an exact and interactive collision detection system, I-COLLIDE, for large-scale environments. Such environments are characterized by the number of objects undergoing rigid motion and the complexity of the models. The algorithm does not assume the objects' motions can be expressed as a closed form function of time. The collision detection system is general and can be easily interfaced with a variety of applications. The algorithm uses a two-level approach based on pruning multiple-object pairs using bounding boxes and performing exact collision detection between selected pairs of polyhedral models. We demonstrate the performance of the system in walkthrough and simulation environments consisting of a large number of moving objects. In particular, the system takes less than 1/20 of a second to determine all the collisions and contacts in an environment consisting of more than 1000 moving polytopes, each consisting of more than 50 faces on an HP-9000/750. <s> BIB001 </s> Finger design automation for industrial robot grippers: A review <s> Collision Detection <s> We present a data structure and an algorithm for efficient and exact interference detection amongst complex models undergoing rigid motion. The algorithm is applicable to all general polygonal models. It pre-computes a hierarchical representation of models using tight-fitting oriented bounding box trees (OBBTrees). At runtime, the algorithm traverses two such trees and tests for overlaps between oriented bounding boxes based on a separating axis theorem, which takes less than 200 operations in practice. It has been implemented and we compare its performance with other hierarchical data structures. In particular, it can robustly and accurately detect all the contacts between large complex geometries composed of hundreds of thousands of polygons at interactive rates. CR <s> BIB002 </s> Finger design automation for industrial robot grippers: A review <s> Collision Detection <s> Collision detection is essential for many applications involving simulation, behavior and animation. However, it has been regarded as a computationallydemanding task and is often treated as an advanced feature. Most commonly used commercial CAD/CAM packages and high performance graphics libraries, such as SGI Performer, provide limited support for collision detection. As users continue to stretch the capabilities of VRML, collision detection will soon become an indispensable capability for many applications. In this paper, we present a system for accelerated and robust collision detection and describe its interface to VRML browsers. We demonstrate that it is possible to perform accurate collision detection at interactive rates in VRML environments composed of large numbers of complex moving objects. CR <s> BIB003 </s> Finger design automation for industrial robot grippers: A review <s> Collision Detection <s> Modular fixturing kits are sets of components used for flexible, rapid construction of fixtures. A modular vise is a parallel-jaw vise, each jaw of which is a modular fixture plate with a regular grid of precisely positioned holes. To fixture a part, one places pins in some of the holes so that when the vise is closed, the part is reliably located and completely constrained. The modular vise concept can be adapted easily to the design of modular parallel-jaw grippers for robots. By attaching a grid-plate to each jaw of a parallel-jaw gripper we gain the ability to easily construct high-quality grasps for a wide variety of parts from a standard set of hardware. Wallack and Canny (1994) developed an algorithm for planning planar grasp configurations for the modular vise. We expand this work to produce a 3D fixture/gripper design tool. We describe several analyses we have added to the planar algorithm, including a 3D grasp quality metric based on force information, 3D geometric loading analysis, and inter-gripper interference analysis. Finally, we describe two applications of our code. One of these is an internal application at Sandia, while the other shows a potential use of our code for designing part of an agile assembly line. <s> BIB004 </s> Finger design automation for industrial robot grippers: A review <s> Collision Detection <s> 0 ABSTRACT In this paper we propose a model for grasping with an industrial parallel-jaw gripper. Two points on the part are candidate ‘grip points’ if they are accessible and are resistant to frictional slip and torque. We formalize these conditions geometrically on a polygonal slice through the part's center of mass. We describe an efficient algorithm for computing and ranking all grip points for an n-sided polygonal slice. The algorithm is part of a design and simulation system that can rapidly provide feedback to designers; thus it must run quickly and reliably. We have implemented the algorithm in a Java applet with a graphical user interface that allows Internet users to define a part; the applet then computes, ranks, and displays the set of computed grip points. To try the applet, please visit: <s> BIB005 </s> Finger design automation for industrial robot grippers: A review <s> Collision Detection <s> An algorithm for automatically generating a common jaw design and planning grasps for a given set of polyhedral objects is presented. The algorithm is suitable for a parallel-jaw gripper equipped with three cylindrical fingers. The common jaw design eliminates the need for custom made grippers and tool changing. The proposed jaw configuration and planning approach reduces the search associated with locating the finger contacts from six degrees-of-freedom to one degree-of-freedom. Closed-form algorithms for checking force closure and for predicting jamming are developed. Three quality metrics are introduced to improve the quality of the planned grasps. The first is a measure of the sensitivity of the grasp to errors between the actual and planned finger locations. The second is a measure of the efficiency of the grasp in terms of the contact forces. The third is a measure of the dependence of force closure on friction. These quality metrics are not restricted to cylindrical fingers and can be applied to n finger grasps. Running on a standard PC, the algorithm generated a solution in less than five minutes for a set of five objects with a total of 456 triangular facets. © 2003 Wiley Periodicals, Inc. <s> BIB006 </s> Finger design automation for industrial robot grippers: A review <s> Collision Detection <s> This paper presents a simple grasp planning method for a multi-fingered hand. Its purpose is to compute a context-independent and dense set or list of grasps, instead of just a small set of grasps regarded as optimal with respect to a given criterion. By context-independent, we mean that only the robot hand and the object to grasp are considered. The environment and the position of the robot base with respect to the object are considered in a further stage. Such a dense set can be computed offline and then used to let the robot quickly choose a grasp adapted to a specific situation. This can be useful for manipulation planning of pick-and-place tasks. Another application is human-robot interaction when the human and robot have to hand over objects to each other. If human and robot have to work together with a predefined set of objects, grasp lists can be employed to allow a fast interaction. The proposed method uses a dense sampling of the possible hand approaches based on a simple but efficient shape feature. As this leads to many finger inverse kinematics tests, hierarchical data structures are employed to reduce the computation times. The data structures allow a fast determination of the points where the fingers can realize a contact with the object surface. The grasps are ranked according to a grasp quality criterion so that the robot will first parse the list from best to worse quality grasps, until it finds a grasp that is valid for a particular situation. <s> BIB007
The key process after designing the fingers structures is collision detection. This process is crucial to ensure the designed fingers would not collide with the workpiece while approaching for grasping. In other words, this process checks the accessibility of the chosen grasp locations. In the last decades, many collision detection modules have been developed for various applications. RAPID BIB002 , I-COLLIDE BIB001 and V-COLLIDE BIB003 are some of collision detection modules freely available to public. Among these, V-COLLIDE is more widely used in robotic research  . However, some researchers developed their own algorithms for detecting collision. BIB005 propose an algorithm for 2D collision detection for parallel-jaw grippers. BIB006 extend BIB005 for 3D objects. Their proposed method starts by projecting the workpiece edges onto the gripper access plane. Then using shooting-ray method to simulate the fingers closing motions. If any intersection between the rays and edges occurrs, the grasp is considered as inaccessible. Despite the fact that the method is quick and simple to implement, it is suitable only for very simple polyhedral objects and has difficulty handling complex shapes. Miller (2004) utilizes a bounding volume hierarchy (BVH) based method, called Proximity Query Package (PQP)  , for detecting collision of manipulating objects. This collision detection module starts with approximating the object surfaces to triangular facets. The collection of the facets for each object are imported to the PQP algorithm to check for collision. In PQP, each objects is modeled as a hierarchy tree (called BVH) so that each leaf represents a facet. BVH trees are used as parents to generate a tree that consists all possible combinations of facets of objects. The latter tree is called bounding volume traversal tree (BVTT)  . The algorithm starts to check the interference for each facets combination (leaf of BVTT) so it detects which facets of the object have interference. In this method, like many other graphic-based methods, there is a trade-off between accuracy and the speed of the detection operation. BIB007 propose a method for detection collision for multifinger robot hands. Their algorithm first discretizes the workspace of fingers to a point cloud. Then the point cloud is converted to a volumetric approximation as a set of spheres. In the last step, the algorithm checks the collision of each sphere with the workpiece, the hand (or gripper) and other fingers. This study presents a fast collision detection method yet it does not provide information regarding exact collision location. Today, most commercial CAD software has in-build collision detecting features which enhance the collecting information regarding the location of the collision (CATIA, 2015; SolidWorks, 2015) . BIB004 use such features to detect collisions in their 3D modular finger design tool. Many collision detection methods have been proposed for a vast range of applications. Some collision detection algorithms are free as modules. While many studies have used these open-source modules, a number of researchers developed their own algorithms that are more or less impossible to verify. Another option to detect a collision is utilizing built-in collision detectors in commercial CAD software. The latter method is the most suitable one for finger design automation for two main reasons. First, it can be integrated with grasp synthesis, grasp analysis and finger design in a CAD tool. Second, by utilizing CAD, more details on the collision location can be extracted which can be helpful in grasp synthesizing and analyzing.