Fastest algorithm to edge detect between two simple rectangles.

Question

Given two simple, rectangles:

class Rectangle
{
    int x;
    int y;
    int width;
    int height;
}

Rectangle a;
Rectangle b;

and the following enumeration:

[Flags]
enum Edges
{
    None,
    Top,
    Bottom,
    Left,
    Right,
    Inside,
}

What is the quickest way to detect the edges on rectangle a which are collided with by rectangle b?

Edges e = EdgeDetect(a, b);

quick = little code, or, quick = fast? also: is x,y a corner or the middle point? — Efrain
– Efrain, Commented Nov 29, 2011 at 8:37
@Rob: SO is not "rent-a-coder", so I am still struggling if I should vote this question down . But if you provide us with your own implementation, the community will happily look at your code and make some suggestions how to improve it. — Doc Brown
– Doc Brown, Commented Nov 29, 2011 at 8:52
@Doc: I suspect it means that b is entirely enclosed by a (without any edges directly intersecting). — Dan Puzey
– Dan Puzey, Commented Nov 29, 2011 at 8:57

hungryMind · Accepted Answer · 2011-11-29 09:15:01Z

2

public Edges DetectEdge(Rect A, Rect B) { 
   rectC = rectA.Intersect(rectB);
    if(rectC.IsEmpty) return Edges.None;
    Edge edge = Edges.Inside;
    if(rectA.X+rectA.Width == rectB.X || rectA.X == rectB.X){
     edge = Edges.Left;
    }
    if(rectA.Y+rectA.Height == rectB.Y || rectA.Y == rectB.Y){
     edge = edge | Edges.Top;
    }
    if(rectA.X  == rectB.X + rectB.Width 
         || rectA.X + rectA.Width == rectB.X + rectB.Width){
     edge = edge | Edges.Right;
    }
    if(rectA.Y == rectB.Y + rectB.Heigth 
         || rectA.Y + rectA.Height == rectB.Y + rectB.Height){
     edge = edge | Edges.Bottom;
    }
    return edge;
}

edited Nov 29, 2011 at 9:15

answered Nov 29, 2011 at 8:49

hungryMind

7,0214 gold badges32 silver badges46 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Steve B Over a year ago

Your code only detect one edge intersection. Instead of returning an Edge, you should bitwise or in each if.

hungryMind Over a year ago

I assumed, he needs another rectA colliding to rectB from outside. Modified the code as per suggested

Steve B · Accepted Answer · 2011-12-01 08:28:17Z

First of all, you have to defines explicitly values of your enum in order to have flags working correctly. In you case Left == Top + Bottom + None. Here is a possible declaration :

[Flags]
public enum Edges
{
    None = 0,
    Top = 1,
    Bottom = 2,
    Left = 4,
    Right = 8,
    Identical = Top + Bottom + Left + Right,
    Inside = 16,
    Covers = 32
}

Next, a possible implementation of edge collision detection. Note that I use the builtin System.Drawing.Rectangle instead of rewriting the class. The immediate advantage is the availability of the Intersect method. :

public static Edges DetectEdgesCollision(Rectangle a, Rectangle b)
{
    var result = Edges.None;

    if (a == b) return Edges.Identical;
    b.Intersect(a);
    if (b.IsEmpty) return Edges.None;
    if (a == b) return Edges.Covers;


    if (a.Top == b.Top && (a.Right >= b.Right && a.Left<=b.Left )) 
        result |= Edges.Top;
    if (a.Bottom == b.Bottom && (a.Right >= b.Right && a.Left<=b.Left ))
        result |= Edges.Bottom;
    if (a.Left == b.Left && (a.Bottom >= b.Bottom && a.Top <= b.Top)) 
        result |= Edges.Left;
    if (a.Right == b.Right && (a.Bottom >= b.Bottom && a.Top <= b.Top)) 
        result |= Edges.Right;


    return result == Edges.None ? Edges.Inside : result;
}

Here is a set of tests that validates this implementation :

    [TestMethod]
    public void RectDoesNotIntersect()
    {
        var a = new Rectangle(0, 0, 10, 10);
        var b = new Rectangle(20, 20, 10, 10);

        var result = Program.DetectEdgesCollision(a, b);

        Assert.AreEqual<Edges>(Edges.None, result);
    }


    [TestMethod]
    public void RectAreNested()
    {
        var a = new Rectangle(0, 0, 30,30);
        var b = new Rectangle(10, 10, 10, 10);

        var result = Program.DetectEdgesCollision(a, b);

        Assert.AreEqual<Edges>(Edges.Inside, result);
    }      
    [TestMethod]
    public void RectCollidesOnTopAndLeft()
    {
        var a = new Rectangle(10, 10, 10, 10);
        var b = new Rectangle(0, 0, 10, 10);

        var result = Program.DetectEdgesCollision(a, b);

        Assert.AreEqual<Edges>(Edges.Left | Edges.Top, result);
    }     
    [TestMethod]
    public void RectCollidesOnBottom()
    {
        var a = new Rectangle(0, 0, 20, 20);
        var b = new Rectangle(10, 10, 5, 50);

        var result = Program.DetectEdgesCollision(a, b);

        Assert.AreEqual<Edges>(Edges.Bottom , result);
    }        

    [TestMethod]
    public void RectAreIdenticals()
    {
        var a = new Rectangle(10, 10, 10, 10);
        var b = new Rectangle(10, 10, 10, 10);

        var result = Program.DetectEdgesCollision(a, b);

        Assert.AreEqual<Edges>(Edges.Identical, result);
    }  
    [TestMethod]
    public void RectBCoversA()
    {
        var a = new Rectangle(10, 10, 10, 10);
        var b = new Rectangle(0, 0, 30, 30);

        var result = Program.DetectEdgesCollision(a, b);

        Assert.AreEqual<Edges>(Edges.Covers, result);
    }

Fantastic response Steve :) - This works really well. The only minor issue is that Identical is returned if Rectangle B is larger than rectangle A and completely covers it. Maybe it should be 'Covers' or 'Engulfs' rather than 'Identical'? Thanks.
You are right, I updated the code. A new enum value Covered is defined, the DetectEdge methode is slightly changed to detect identical first, then covers, then per edge. A new Test has also been added.

Collectives™ on Stack Overflow

Fastest algorithm to edge detect between two simple rectangles.

2 Answers 2

2 Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related