A multi-threaded algorithm for computing the largest non-colliding moving geometry
Introduction
Being able to determine whether a virtual object can pass through a virtual environment without collision is a fundamental problem in virtual design. Depending on the exact problem at hand, there exist hundreds of papers addressing this problem from all sorts of aspects. In this paper we focus on a lesser studied problem of utmost importance for industrial designers. We are interested in being able to compute the largest object that can travel collision-free from a start configuration to a goal configuration. By the largest object we mean the object that has the largest volume according to some user defined way of measuring volume (as explained below). In this paper, we confine the object to travel along a fixed trajectory through a fixed virtual environment.
This academic investigation is motivated by numerous real life problems (see below) and the basic motivation for this article is the virtual verification of car designs. In particular, one wants to know if a new car design can pass through an assembly line without colliding with other objects and if it does collide, what are the minimal design changes that need to be made to avoid the collisions. This information can also be used for future design problems if the environment and trajectory remain the same (as is typical for factory installations).
Another motivation for this study was to improve the sustainability of current technologies. In particular, the results of this paper are intended to allow companies to reuse the existing facilities by giving designers a guarantee that their new designs fit in the current industrial installation and also letting them know the minimum changes to both the object they are designing and/or the industrial environment if necessary. This virtual verification saves the designer significant time much earlier in the design phase. Currently to determine whether a new model design fits along an assembly line or not, one is required to build a physical mock-up of a car (or whatever is being produced) and run it through an assembly line to check for collisions. Such a process is obviously much slower and costlier than having a simple virtual tool to directly test a new design and suggest which minimal changes need to be made.
Significant design changes are often very costly, hence the goal of many designers is to know what the minimal structural design changes are to make sure objects do not collide with each other. Typical applications where computing the largest non-colliding designs plays an important role include, inter alia, the ability to route and path plan objects through tight spaces such as engines [1] and other assembly components, designing robots for tight spaces in path planning applications [2], [3], etc. Once the set of colliding parts has been discovered one can then apply any of the numerous algorithms to effect the necessary design changes to avoid collisions (e.g. [4], [5]).
The problem we are interested in can be defined more exactly as follows. Let be some geometrical object (set of NURBs, polygon soup, points, etc.) that bounds some volume of space and another geometrical object (representing the surrounding environment). We wish to compute the remaining non-colliding space bounded by after has traveled along a given trajectory (motion, path, etc.) defined by a set of rigid transformations. We would like to remove all parts of the space bound by that collide with any part of during the set of rigid transformations. From the design perspective, the remaining non-colliding volume can be used to alter the original geometry so that it can pass along the original path collision-free. In addition, we are also interested in determining how much larger can be and still have parts of the enlarged volume not colliding with any part of .
To compute the largest remaining non-colliding volume to travel along a given path, we developed an algorithm as follows. Our algorithm first allows the user to specify the largest volume object they are interested in, say . We then compute a bounding box around and divide the box into smaller subboxes with fixed side lengths defined by the user (so-called tolerance). This size represents the level of error acceptable to the user. An hash-based octree containing the surrounding environment is then created and used to compute collisions between the environment and the object during its motion. As collisions are detected between the subboxes and the octree, subboxes are removed. The final remaining set of subboxes left at the end of the motion represents the largest shape that can pass through the environment along the path with the given user tolerance. The algorithms used here are located at the confluence of algorithms for finding the maximum empty subset of a given domain [6], collision detection [7] and being able to compute boolean operations for arbitrary geometries [8].
The remainder of this paper is organized as follows. In the next section, we present our algorithm and its analysis as well as the existing literature relevant to each part of the algorithm. We then present our experimental results, which are followed by a discussion of the results from the previous section. In the final section we conclude.
Section snippets
Methods
In this section, we describe an algorithm that solves the problem stated in the introduction. When designing the algorithm we wish to bear a few goals in mind. First of all, if the algorithm is to be run in the main memory, then it needs to have minimal space requirements because it will be used for point clouds with millions (or billions) of points. In spite of this, we do not want an unnecessarily slow algorithm for computing the final non-colliding geometry because the algorithm will be used
Results
The bounding box of the object that moved through the point cloud had a volume of . It is dimensions were 4.80 m by 2.37 m by 0.68 m. We present the number of subboxes for each of the object tolerances in Table 1 (recall that when testing for collision we only tested against the outer boundary of the subboxes). The trajectory that the object followed was 222 m long had 14 nonlinear section where the object rotated either downwards and then upwards (to the horizontal plane) or vice versa.
Discussion
In Table 4 we can see the results of the first test. They demonstrate a good relationship between the number of points and the other variables. We can see that the octree build time scales linearly with the number of points and, apart from the anomalous result for the one million point cloud, the movement time is approximately independent of the density of the points. The anomalous result for the one million point case is due to the larger number of boxes on the boundary of the moving object
Conclusion
In this article we have presented an algorithm to solve the designer’s problem of determining the minimal volume reduction of an object so that it can move collision free along a given path. The paper fills an important gap at the intersection of many areas of research as outlined in the introduction. When developing our algorithms we attempted to not restrict ourselves to specific geometries or movements. There were no physical restrictions on the object’s movements and the algorithm also
Acknowledgments
The authors sincerely thank Mathias Sundbäck and Magnus Rönnäng from Volvo Cars for their support and assistance in carrying out this research. We also thank Volvo Cars for their kind allowance of the simulation photos and data used in this paper. This work was carried out at the Wingquist Laboratory VINN Excellence Centre, and is part of the Sustainable Production Initiative and the Production Area of Advance at Chalmers University of Technology. It was supported by the Swedish Governmental
References (20)
- et al.
Topological simplification of isosurfaces in volumetric data using octrees
Graph Models
(2008) - et al.
MCCD: multi-core collision detection between deformable models using front-based decomposition
Graph Models
(2010) - et al.
Automatic assembly path planning for wiring harness installations
J Manuf Syst
(2013) - Spensieri D, Ekstedt F, Torstensson J, Bohlin R, Carlson JS. Throughput maximization by balancing, sequencing and...
- et al.
Integrating assembly design, sequence optimization, and advanced path planning
- Björkenstam S, Segeborn J, Carlson JS, Bohlin R. Assembly verification and geometry design by distance field based...
- et al.
Maximal empty boxes amidst random points
- et al.
Hybrid booleans
Comput Graph Forum
(2010) - et al.
A parallel hashed oct-tree -body algorithm
- et al.
Swept volumes: fundation, perspectives, and applications
Int J Shape Model
(2006)
Cited by (4)
Visualization of AGV in Virtual Reality and Collision Detection with Large Scale Point Clouds
2018, Proceedings - IEEE 16th International Conference on Industrial Informatics, INDIN 2018Maximizing Smart Factory Systems by Incrementally Updating Point Clouds
2015, IEEE Computer Graphics and ApplicationsA heuristic framework for path planning the largest volume object from a start to goal configuration
2014, ICINCO 2014 - Proceedings of the 11th International Conference on Informatics in Control, Automation and Robotics