How to get overlapping rectangle coordinates

Question

Assume I have the following overlapping rectangles (\"a\" and \"b\"):

aaaaaaaa
aaaaccccbbbbb
aaaaccccbbbbb
aaaaccccbbbbb
    bbbbbbbbb
    bbbbbbbbb

Answer 1

Call Rectangle.Intersect.

Answer 2

static internal Rectangle intersect(Rectangle lhs, Rectangle rhs)
{
    Dimension lhsLeft = lhs.Location.X;
    Dimension rhsLeft = rhs.Location.X;
    Dimension lhsTop = lhs.Location.Y;
    Dimension rhsTop = rhs.Location.Y;
    Dimension lhsRight = lhs.Right;
    Dimension rhsRight = rhs.Right;
    Dimension lhsBottom = lhs.Bottom;
    Dimension rhsBottom = rhs.Bottom;

    Dimension left = Dimension.max(lhsLeft, rhsLeft);
    Dimension top = Dimension.max(lhsTop, rhsTop);
    Dimension right = Dimension.min(lhsRight, rhsRight);
    Dimension bottom = Dimension.min(lhsBottom, rhsBottom);
    Point location = new Point(left, top);
    Dimension width = (right > left) ? (right - left) : new Dimension(0);
    Dimension height = (bottom > top) ? (bottom - top) : new Dimension(0);

    return new Rectangle(location, new Size(width, height));
}

Answer 3

I used an abstract validator for my project and to check if some layout controls where overlapping I created rectangles out of the layout figures:

RuleFor(p => DoControlsIntersect(p.PageControls.Select(x => new Rectangle(x.Row, x.Column, x.Width, x.Height)).ToList())).Equal(false).WithMessage(OverlappingFields);

private bool DoControlsIntersect(List<Rectangle> rectangles)
        {
            return rectangles.Any(rect => rectangles.Where(r => !r.Equals(rect)).Any(r => r.IntersectsWith(rect)));
        }

Answer 4

The X coordinates of the overlap area of two rectangles can be found according to the following logic.

To find the Y coordinates, substitute Y for X in the last of the four assumptions, as well as in all of the three cases.

---

Assumptions:

• A and B are rectangles (with their sides aligned along the X and Y axes),

• each of the rectangles is defined by two points   (x_min / y_min) – (x_max / y_max)

• where x_min < x_max   and   y_min < y_max  .

• A.x_min < B.x_min

---

Case 1 — No overlap:

+--------+
|A       |    
|        |    +----+
|        |    |B   |
|        |    +----+
|        |
+--------+

A.x_min < A.x_max < B.x_min < B.x_max   ⇒   No overlap.

---

Case 2 — Some overlap:

+--------+
|A       |
|     +--+-+
|     |B | |
|     +--+-+
|        |
+--------+

A.x_min < B.x_min < A.x_max < B.x_max   ⇒   Overlap X coordinates: B.x_min – A.x_max

---

Case 3 — Complete overlap:

+--------+
|A       |
| +----+ |
| |B   | |
| +----+ |
|        |
+--------+

A.x_min < B.x_min < B.x_max < A.x_max   ⇒   Overlap X coordinates: B.x_min – B.x_max

---

P.S.: You can actually further simplify this algorithm. The overlap X coordinates are always:

max(A.x_min, B.x_min) – min(A.x_max, B.x_max)

except when the second value is less than the first; that means that there is no overlap.

Answer 5

Assume:

Points of   rectangle R1: R1.A(x,y), R1.B(x,y), R1.C(x,y), R1.D(x,y)   
Points of   rectangle R2: R2.A(x,y), R2.B(x,y), R2.C(x,y), R2.D(x,y)   
Overlapping rectangle RO: RO.A(x,y), RO.B(x,y), RO.C(x,y), RO.D(x,y)    
Standard cartesian coordinates (positive is right and upwards).

Overlapping rectangle RO computes as follows with C#:

RO.A.x = Math.Min(R1.A.x, R2.A.x);
RO.A.y = Math.Max(R1.A.y, R2.A.y);
RO.C.x = Math.Max(R1.C.x, R2.C.x);
RO.C.y = Math.Min(R1.C.y, R2.C.y);
RO.B(x,y) and RO.D(x,y) = ....

Inner rectangle RI:

Swap Min and Max in above solution for overlapping rectangle RO.