Fast circle collision detection

Question

I'm trying to write a method that will calculate if two circles are overlapping. I've come up with the following and I'm just curious to know if there is anyway it could be optimised further.

private static boolean isCollision(Point2D p1, float r1, Point2D p2, float r2)
{
    float a,dx, dy;
    a = (r1+r2) * (r1+r2);
    dx = (float) (p1.getX() - p2.getX());
    dy = (float) (p1.getY() - p2.getY());

    if (a > (dx*dx) + (dy*dy))
    {
        return true;
    }
    return false;
}

Answer 1

Hmm. That looks pretty good as far as the math goes. Some minor points on how to make the Java side of it faster and terser:

• If you used doubles instead of floats for the radii, you wouldn't have to down-cast the doubles to floats.
• If you specifically ask for Point2D.Double parameters, you can use their x and y public fields instead of using the getters.
• Also, why the if (foo) { return true; } else { return false; }? if (foo) { return true; } else { return false; }? Just do return foo; !

An improved version, then:

private static boolean isCollision(Point2D.Double p1, double r1, Point2D.Double p2, double r2)
{
    final double a = r1 + r2;
    final double dx = p1.x - p2.x;
    final double dy = p1.y - p2.y;
    return a * a > (dx * dx + dy * dy);
}

(Note that if your code is entirely float-based, you can do the same thing with Point2D.Float and float s.)

Answer 2

Overlap or intersect?

If intersect, don't forget about the case where the circles don't intersect because they are inside each other.

If it's overlap, I don't really see how you could optimize further; you're comparing the point distances to the sum of the radii, using distance squared to avoid taking a square root. Doesn't seem like there's any fat left to trim.

Answer 3

Do you really need to cater for any possible Point2D implementation? If you don't have to, it will save a virtual call:

private static boolean isCollisionFloat (Point2D.Float p1, float r1, Point2D.Float p2, float r2)
{
    final float r = r1+r2;
    final float dx = p1.x - p2.x;
    final float dy = p1.y - p2.y;

    return (r*r) > (dx*dx) + (dy*dy);
}

testing 1000x1000 points:
Doing nothing took 6 ms
Doing isCollision passing Point2D.Float took 128 ms
Doing isCollision passing Point2D.Double took 127 ms
Doing isCollisionFloat took 71 ms
Doing isCollisionDouble took 72 ms

If you can, choose one or the other, rather than catering for both.

---

The problem with perf questions is that you really do have to measure the effects, by which time someone has posted the same answer as unsupported opinion.

Answer 4

我不知道你的情况是否相关，但是如果你想检查你的圈子和许多其他圈子之间的重叠（让我们说成千上万的圈子），你可以尝试在四叉树中组织你的圈子（参见http： //en.wikipedia.org/wiki/Quadtree ）并在四叉树中进行树查找（基于圆的边界矩形）。

Answer 5

Your algorithm can be further optimized by calculating the rectangular bounds of each circle and seeing if they overlap. If they don't overlap then just return false. This avoids multiplication for those circles who's rectangular bounds don't overlap (ie, they aren't close to each other). Addition/subtraction for the rectangular bound calculation is cheaper than multiplication.

This is the pattern that Java 2D uses. See Shape.getBounds()

Answer 6

它不会使你的代码更快，但我更喜欢：

return a > (dx*dx + dy*dy);