logic - Java method to find the rectangle that is the intersection of two rectangles using only left bottom point, width and height?

Question

I have found the solution but wanted to ensure my logic is the most efficient. I feel that there is a better way. I have the (x,y) coordinate of the bottom left corner, height and width of 2 rectangles, and i need to return a third rectangle that is their intersection. I do not want to post the code as i feel it is cheating.

1. I figure out which is furthest left and highest on the graph.
2. I check if one completely overlaps the other, and reverse to see if the other completely overlaps the first on the X axis.
3. I check for partial intersection on the X axis.
4. I basically repeat steps 2 and 3 for the Y axis.
5. I do some math and get the points of the rectangle based on those conditions.

I may be over thinking this and writing inefficient code. I already turned in a working program but would like to find the best way for my own knowledge. If someone could either agree or point me in the right direction, that would be great!

Answer 1

Why not use JDK API to do this for you?

Rectangle rect1 = new Rectangle(100, 100, 200, 240);
Rectangle rect2 = new Rectangle(120, 80, 80, 120);
Rectangle intersection = rect1.intersection(rect2);

To use java.awt.Rectangle class, the parameters of the constructor are: x, y, width, height, in which x, y are the top-left corner of the rectangle. You can easily convert the bottom-left point to top-left.

---

I recommend the above, but if you really want to do it yourself, you can follow the steps below:

say (x1, y1), (x2, y2) are bottom-left and bottom-right corners of Rect1 respectively, (x3, y3), (x4, y4) are those of Rect2.

• find the larger one of x1, x3 and the smaller one of x2, x4, say xL, xR respectively
  • if xL >= xR, then return no intersection else
• find the larger one of y1, y3 and the smaller one of y2, y4, say yT, yB respectively
  • if yT >= yB, then return no intersection else
  • return (xL, yB, xR-xL, yB-yT).

A more Java-like pseudo code:

// Two rectangles, assume the class name is `Rect`
Rect r1 = new Rect(x1, y2, w1, h1);
Rect r2 = new Rect(x3, y4, w2, h2);

// get the coordinates of other points needed later:
int x2 = x1 + w1;
int x4 = x3 + w2;
int y1 = y2 - h1;
int y3 = y4 - h2;

// find intersection:
int xL = Math.max(x1, x3);
int xR = Math.min(x2, x4);
if (xR <= xL)
    return null;
else {
    int yT = Math.max(y1, y3);
    int yB = Math.min(y2, y4);
    if (yB <= yT)
        return null;
    else
        return new Rect(xL, yB, xR-xL, yB-yT);
}

As you see, if your rectangle was originally defined by two diagonal corners, it will be easier, you only need to do the // find intersection part.