I had a somewhat late start on this project because it had taken me some time to decide on a specific topic, but I started off by doing a fair amount of background reading on convex decompositions. The first course of action was to find out more about how convex decompositions are generally done, and what they are used for. Convex decompositions of arbitrary polyhedra have been used for applications in which nonconvexity drastically increases complexity, such as in collision detection and penetration depth calculation. I read through several papers (listed at the bottom of this page) on these topics (many from UNC). I have been looking into the decomposition algorithm used in UNC's SWIFT++ as a starting point for my own ideas.
Some decomposition algorithms may be more useful for certain applications than others, but I have been concentrating on convex decomposition from the viewpoint of collision detection and proximity queries, as in SWIFT++. For these kinds of queries, convex surface decomposition is generally preferred over convex solid decomposition because the output of convex surface decompositions is usually far less than that of convex solid decompositions. This allows for subsequent proximity queries to be carried out more efficiently because there are less primitives to compare against.
I have received the code for SWIFT++ as well as some additional code written by Miguel Otaduy and have spent a fair amount of time trying to understand the code structure and data structures involved, in particular for the code involving decomposition. As is generally the case when trying to understand an unfamiliar code base, this is quite a time-consuming process. I am still not completely familiar with the inner workings of the code, but I hope to be able to understand it well enough to either modify it or write new code to implement my own ideas.
Currently, in SWIFT++, convex surface decompositions are done with a greedy algorithm that attempts to use a small amount of memory for the resulting convex hulls of convex patches. This seems to yield good results in many cases but there may be ways to improve this by using different algorithms.
SWIFT++'s decomposer essentially (I am leaving many details out here) finds convex surface decompositions by starting from some face in the polyhedron and scanning through its adjacent faces using a breadth-first or depth-first search and adding faces while the set of these faces is still convex and the convex hull of this set of faces is completely contained within the original geometry of the polyhedron. There are some other constraints as well.
The first idea I had thought of involved taking faces from "opposing sides" of polyhedra to create convex patches, since it might be possible to create fewer pieces by exploiting convexity on different (non-adjacent) parts of polyhedra. This was before I had looked into the topic much. This does not seem to be particularly useful because in general it probably is not possible to find many instances of "non-adjacent" convexity, or at least not enough to make a difference in the resulting number of pieces. Secondly, the convex pieces generated would be intersecting in the interior of the polyhedron, which would cause problems when constructing a hierarchical bounding volume structure for collision detection and proximity queries.
After talking to Miguel it seems that it may be most useful to have patches whose convex hulls exhibit some sort of "equality" in spatial terms. In other words, it may be valuable to construct pieces that have approximately the same number of faces, have approximately the same surface area, or encompass approximately the same volume in space. While this may not create a minimal number of convex patches (NP-complete), it may help a great deal in creating balanced hierarchical bounding volume structures for collision detection and proximity queries.
I hope to soon be able to begin implementing some of these ideas after I more fully understand the decomposition code base.
Ehmann, Stephen A., Lin, Ming C. Accurate and Fast Proximity Queries Between Polyhedra Using Convex Surface Decomposition, EUROGRAPHICS 2001.
Kim, Young J., Otaduy, Migual A., Lin, Ming C., Manocha, Dinesh. Fast Penetration Depth Computation for Physically-based Animation, ACM Symposium on Computer Animation, July 21-22, 2002.
Lin, Ming C., Canny, John F. A Fast Algorithm for Incremental Distance Calculation, Proceedings of the 1991 IEEE International Conference on Robotics and Automation, April 1991.
Chazelle, B. Convex Partitions of Polyhedra: A Lower Bound and Worst-Case Optimal Algorithm, SIAM J. Comp., Vol. 13, No. 3, August 1984.
Bajaj, C. L., Dey, T. K., Convex Decomposition of Polyhedra and Robustness, SIAM J. Comp., Vol. 21, No. 2, April 1992.
Kim, Young J., Lin, Ming C., Manocha, Dinesh. DEEP: Dual-space Expansion for Estimating Penetration Depth Between Convex Polytopes, Proc. IEEE International Conference on Robotics and Automation, May 11-15, 2002.