在3D中找到2个任意立方体的交集

Question

So, I'd like to figure out a function that allows you to determine if two cubes of arbitrary rotation and size intersect.

If the cubes are not arbitrary in their rotation (but locked to a particular axis) the intersection is simple; you check if they intersect in all three dimensions by checking their bounds to see if they cross or are within one another in all three dimensions. If they cross or are within in only two, they do not intersect. This method can be used to determine if the arbitrary cubes are even candidates for intersection, using their highest/lowest x, y, and z to create an outer bounds.

That's the first step. In theory, from that information we can tell which 'side' they are on from each other, which means we can eliminate some of the quads (sides) from our intersection. However, I can't assume that we have that information, since the rotation of the cubes may make it difficult to determine simply.

My thought is to take each pair of quads, find the intersection of their planes, then determine if that line intersects with at least one edge of each of the pairs of sides. If any pair of sides has a line of intersection that intersects with any of their edges, the quads intersect. If none intersect, the two cubes do not intersect.

We can then determine the depth of the intersection on the second cube by where the plane-intersection line intersects with its edge(s).

This is simply speculative, however. Is there a better, more efficient way to determine the intersection of these two cubes? I can think of a number of different ways to do this, and I can also tell that they could be very different in terms of amount of computation required.

I'm working in Java at the moment, but C/C++ solutions are cool too (I can port them); even psuedocode since it is perhaps a big question.

Answer 1

You should take a look at the field of computer graphics. They have many means. Eg Weiler–Atherton clipping algorithm . There are also many datastructures that could ease up the process for you. To mention AABBs ( Axis-aligned bounding boxes ).

Answer 2

To find the intersection (contact) points of two arbitrary cubes in three dimensions, you have to do it in two phases:

1. Detect collisions. This is usually two phases itself, but for simplicity, let's just call it "collision detection".

The algorithm will be either SAT (Separating axis theorem), or some variant of polytope expansion/reduction. Again, for simplicity, let's assume you will be using SAT.

I won't explain in detail, as others have already done so many times, and better than I could. The "take-home" from this, is that collision detection is not designed to tell you where a collision has taken place; only that it has taken place.

2. Upon detection of an intersection, you need to compute the contact points. This is done via a polygon clipping algorithm. In this case, let's use https://en.wikipedia.org/wiki/Sutherland%E2%80%93Hodgman_algorithm

There are easier, and better ways to do this, but SAT is easy to grasp in 3d, and SH clipping is also easy to get your head around, so is a good starting point for you.

Answer 3

Try using the separating axis theorem. it should apply in 3d as it does in 2d.

Answer 4

If you create polygons from the sides of the cubes then another approach is to use Constructive Space Geometry (CSG) operations on them. By building a Binary Space Partitioning (BSP) tree of each cube you can perform an intersection on them. The result of the intersection is a set of polygons representing the intersection. In your case if the number of polygons is zero then the cubes don't intersect.

I would add that this approach is probably not a good real time solution, but you didn't indicate if this needed to happen in frame refresh time or not.

Since porting is an option you can look at the Javascript library that does CSG located at

http://evanw.github.io/csg.js/docs/

I've ported this library to C# at

https://github.com/johnmott59/CGSinCSharp