How can I efficiently detect collision between image layers and generated shapes?
I need a fast and comprehensive method to detect collision between rotatable image layers and generated shapes. 
So far I have just been dividing images into a series of circles that contain the majority of the pixels and then testing each circle against other shapes. To enhance performance I created perimeter circles around each structure and only test these larger circles until two structures are close enough to collide.
The real problem is that it is very difficult to collide a rotatable rectangle, for example, into one of these image structures. Filling a rectangle with circles also just does not seem efficient. Not to mention that I'm getting combinatoric explosions that make looping very complex and poor performance.
Anyone know a better way to handle this type of collision? I write in Java, Python and C. I am willing to use C++ also.
Normally, sphere collisions are just filter for real collision tests.
You can either:

decide to limit collisions to that, for example if it's a game.
implement real collisions and do the full math. You're basically intersecting the rotated edges of the two rectangles (16 cases). Intersect two edges as if they were lines, there will be only one point of intersection (unless they're parallel), if that point is inside the segment there's a collision.

To limit complexity, you can use a quadtree/octree. Divide your space into four rectangles, then those rectangles into four etc ... until they're too small to contain an object or are empty. Put your collidable objects into the most specific part of the tree that will contain them. Two objects can only collide if they are in the same sub rectangle or one is in any parent of the other.
Not sure that helps, but they're ideas.
Collision detection between image layers and shapes