wake-up-neo.net

Bestimmen Sie, ob sich zwei Rechtecke überlappen?

Ich versuche, ein C++ - Programm zu schreiben, das die folgenden Eingaben des Benutzers zum Erstellen von Rechtecken (zwischen 2 und 5) benötigt: height, width, x-pos, y-pos. Alle diese Rechtecke werden parallel zur x- und y-Achse vorhanden sein, das heißt, alle ihre Kanten haben Neigungen von 0 oder unendlich.

Ich habe versucht, das, was in this question erwähnt wird, umzusetzen, aber ich habe nicht viel Glück.

Meine aktuelle Implementierung führt Folgendes aus:

// Gets all the vertices for Rectangle 1 and stores them in an array -> arrRect1
// point 1 x: arrRect1[0], point 1 y: arrRect1[1] and so on...
// Gets all the vertices for Rectangle 2 and stores them in an array -> arrRect2

// rotated Edge of point a, rect 1
int rot_x, rot_y;
rot_x = -arrRect1[3];
rot_y = arrRect1[2];
// point on rotated Edge
int pnt_x, pnt_y;
pnt_x = arrRect1[2]; 
pnt_y = arrRect1[3];
// test point, a from rect 2
int tst_x, tst_y;
tst_x = arrRect2[0];
tst_y = arrRect2[1];

int value;
value = (rot_x * (tst_x - pnt_x)) + (rot_y * (tst_y - pnt_y));
cout << "Value: " << value;  

Ich bin mir jedoch nicht ganz sicher, ob (a) ich den Algorithmus, mit dem ich verlinkt habe, richtig implementiert habe oder ob ich genau wusste, wie ich das interpretieren soll?

Irgendwelche Vorschläge?

295
Rob Burke
if (RectA.Left < RectB.Right && RectA.Right > RectB.Left &&
     RectA.Top > RectB.Bottom && RectA.Bottom < RectB.Top ) 

oder mit kartesischen Koordinaten 

(Mit X1 als linker Coord, X2 als rechter Coord, von links nach rechts steigend und Y1 als oberer Coord und Y2 als unterer Coord, von unten nach oben steigend) ...

if (RectA.X1 < RectB.X2 && RectA.X2 > RectB.X1 &&
    RectA.Y1 > RectB.Y2 && RectA.Y2 < RectB.Y1) 

HINWEIS: AN ALLE SO BENUTZER MIT BEARBEITUNGSBEHÖRDE. BITTE BEENDIGEN SIE AUF DIESEM FIDDLING.

Angenommen, Sie haben Rekt A und Rekt B Der Beweis ist widersprüchlich. Eine von vier Bedingungen garantiert, dass keine Überschneidung bestehen kann :

  • Cond1. Wenn sich der linke Rand von A rechts vom rechten Rand von B befindet, - dann steht A ganz rechts von B
  • Cond2. Wenn sich der rechte Rand von A links vom linken Rand von B befindet, wird - dann ist A ganz links von B
  • Cond3. Wenn sich die obere Kante von A unter der unteren Kante von B befindet, - dann ist A total unter B
  • Cond4. Wenn der untere Rand von A über dem oberen Rand von B liegt, wird - dann liegt A völlig über B

Bedingung für Nichtüberlappung ist also 

Cond1 oder Cond2 oder Cond3 oder Cond4

Eine ausreichende Bedingung für die Überlappung ist daher das Gegenteil. 

Nicht (Cond1 oder Cond2 oder Cond3 oder Cond4)

De Morgans Gesetz sagt
Not (A or B or C or D)

Das ist äquivalent zu:

  • Linker Rand von A nach links vom rechten Rand von B, [RectA.Left < RectB.Right] und
  • A's rechter Rand rechts von B's linkem Rand, [RectA.Right > RectB.Left] und
  • A oben über B unten, [RectA.Top > RectB.Bottom] und
  • A's Unterseite unter B's Top [RectA.Bottom < RectB.Top]

Anmerkung 1 : Es ist ziemlich offensichtlich, dass dieses Prinzip auf eine beliebige Anzahl von Dimensionen erweitert werden kann.
Hinweis 2 : Es sollte auch naheliegend sein, Überlappungen von nur einem Pixel zu zählen, den < und/oder den > an dieser Grenze in einen <= oder einen >= zu ändern.
Anmerkung 3 : Diese Antwort basiert auf kartesischen Koordinaten (X, Y) und basiert auf algebraischen kartesischen Standardkoordinaten (x steigt von links nach rechts und Y von unten nach oben). Wenn ein Computersystem Bildschirmkoordinaten möglicherweise anders mechanisiert (z. B. durch Erhöhen von Y von oben nach unten oder X von rechts nach links), muss die Syntax entsprechend angepasst werden. 

639
Charles Bretana
struct rect
{
    int x;
    int y;
    int width;
    int height;
};

bool valueInRange(int value, int min, int max)
{ return (value >= min) && (value <= max); }

bool rectOverlap(rect A, rect B)
{
    bool xOverlap = valueInRange(A.x, B.x, B.x + B.width) ||
                    valueInRange(B.x, A.x, A.x + A.width);

    bool yOverlap = valueInRange(A.y, B.y, B.y + B.height) ||
                    valueInRange(B.y, A.y, A.y + A.height);

    return xOverlap && yOverlap;
}
108
e.James
struct Rect
{
    Rect(int x1, int x2, int y1, int y2)
    : x1(x1), x2(x2), y1(y1), y2(y2)
    {
        assert(x1 < x2);
        assert(y1 < y2);
    }

    int x1, x2, y1, y2;
};

bool
overlap(const Rect &r1, const Rect &r2)
{
    // The rectangles don't overlap if
    // one rectangle's minimum in some dimension 
    // is greater than the other's maximum in
    // that dimension.

    bool noOverlap = r1.x1 > r2.x2 ||
                     r2.x1 > r1.x2 ||
                     r1.y1 > r2.y2 ||
                     r2.y1 > r1.y2;

    return !noOverlap;
}
26
David Norman

Es ist einfacher zu prüfen, ob sich ein Rechteck vollständig außerhalb des anderen befindet, also ob es eines ist 

auf der Linken... 

(r1.x + r1.width < r2.x)

oder auf der rechten Seite ... 

(r1.x > r2.x + r2.width)

oder oben ... 

(r1.y + r1.height < r2.y)

oder auf der Unterseite ... 

(r1.y > r2.y + r2.height)

des zweiten Rechtecks ​​kann es unmöglich mit ihm kollidieren. Um eine Funktion zu haben, die ein boolesches Sprichwort zurückgibt, wenn die Rechtecke kollidieren, kombinieren wir die Bedingungen einfach durch logische ODERs und negieren das Ergebnis:

function checkOverlap(r1, r2) : Boolean
{ 
    return !(r1.x + r1.width < r2.x || r1.y + r1.height < r2.y || r1.x > r2.x + r2.width || r1.y > r2.y + r2.height);
}

Um bereits beim Berühren ein positives Ergebnis zu erhalten, können Sie die "<" und ">" durch "<=" und "> =" ändern.

21
Björn Kechel

Angenommen, Sie haben die Positionen und Größen der Rechtecke folgendermaßen definiert:

enter image description here

Meine C++ - Implementierung sieht so aus:

class Vector2D
{
    public:
        Vector2D(int x, int y) : x(x), y(y) {}
        ~Vector2D(){}
        int x, y;
};

bool DoRectanglesOverlap(   const Vector2D & Pos1,
                            const Vector2D & Size1,
                            const Vector2D & Pos2,
                            const Vector2D & Size2)
{
    if ((Pos1.x < Pos2.x + Size2.x) &&
        (Pos1.y < Pos2.y + Size2.y) &&
        (Pos2.x < Pos1.x + Size1.x) &&
        (Pos2.y < Pos1.y + Size1.y))
    {
        return true;
    }
    return false;
}

Ein Beispiel für einen Funktionsaufruf gemäß der obigen Abbildung:

DoRectanglesOverlap(Vector2D(3, 7),
                    Vector2D(8, 5),
                    Vector2D(6, 4),
                    Vector2D(9, 4));

Die Vergleiche im if-Block sehen wie folgt aus:

if ((Pos1.x < Pos2.x + Size2.x) &&
    (Pos1.y < Pos2.y + Size2.y) &&
    (Pos2.x < Pos1.x + Size1.x) &&
    (Pos2.y < Pos1.y + Size1.y))
                 ↓  
if ((   3   <    6   +   9    ) &&
    (   7   <    4   +   4    ) &&
    (   6   <    3   +   8    ) &&
    (   4   <    7   +   5    ))
6
hkBattousai

Stellen Sie sich die entgegengesetzte Frage: Wie kann ich feststellen, ob sich zwei Rechtecke überhaupt nicht schneiden? Offensichtlich schneidet sich ein Rechteck A, das sich ganz links vom Rechteck B befindet, nicht. Auch wenn A ganz rechts ist. Und in ähnlicher Weise, wenn A vollständig über B oder vollständig unter B liegt. In jedem anderen Fall schneiden A und B.

Was folgt, kann Fehler enthalten, aber ich bin mit dem Algorithmus ziemlich zuversichtlich:

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

bool is_left_of(Rectangle const & a, Rectangle const & b) {
   if (a.x + a.width <= b.x) return true;
   return false;
}
bool is_right_of(Rectangle const & a, Rectangle const & b) {
   return is_left_of(b, a);
}

bool not_intersect( Rectangle const & a, Rectangle const & b) {
   if (is_left_of(a, b)) return true;
   if (is_right_of(a, b)) return true;
   // Do the same for top/bottom...
 }

bool intersect(Rectangle const & a, Rectangle const & b) {
  return !not_intersect(a, b);
}
6
coryan

So wird es in der Java-API gemacht:

public boolean intersects(Rectangle r) {
    int tw = this.width;
    int th = this.height;
    int rw = r.width;
    int rh = r.height;
    if (rw <= 0 || rh <= 0 || tw <= 0 || th <= 0) {
        return false;
    }
    int tx = this.x;
    int ty = this.y;
    int rx = r.x;
    int ry = r.y;
    rw += rx;
    rh += ry;
    tw += tx;
    th += ty;
    //      overflow || intersect
    return ((rw < rx || rw > tx) &&
            (rh < ry || rh > ty) &&
            (tw < tx || tw > rx) &&
            (th < ty || th > ry));
}
3
Lyle

In der Frage verknüpfen Sie mit der Mathematik, wann Rechtecke sich in beliebigen Drehwinkeln befinden. Wenn ich das bisschen über Winkel in der Frage verstehe, stelle ich jedoch fest, dass alle Rechtecke senkrecht zueinander stehen.

Ein allgemeines Wissen über den Bereich der Überlappungsformel ist:

Verwenden Sie das Beispiel:

    1 2 3 4 5 6 

 1 + --- + --- + 
 | | 
 2 + A + --- + --- + 
 | | B | 
 3 + + + --- + --- + 
 | | | | | 
 4 + --- + --- + --- + --- + + 
 | | 
 5 + C + 
 | | 
 6 + --- + --- + 

1) Sammeln Sie alle x-Koordinaten (links und rechts) in einer Liste, sortieren Sie sie und entfernen Sie Duplikate

1 3 4 5 6

2) Sammeln Sie alle y-Koordinaten (oben und unten) in einer Liste, sortieren Sie sie und entfernen Sie Duplikate

1 2 3 4 6

3) Erstellen Sie ein 2D-Array nach Anzahl der Lücken zwischen den eindeutigen x-Koordinaten * Anzahl der Lücken zwischen den eindeutigen y-Koordinaten.

4 * 4

4) Malen Sie alle Rechtecke in dieses Raster und erhöhen Sie die Anzahl der Zellen, über denen sie auftritt:

 1 3 4 5 6 

 1 + --- + 
 | 1 | 0 0 0 
 2 + --- + --- + --- + 
 | 1 | 1 | 1 | 0 
 3 + --- + --- + --- + --- + 
 | 1 | 1 | 2 | 1 | 
 4 + --- + --- + --- + --- + 
 0 0 | 1 | 1 | 
 6 + --- + --- + 

5) Wenn Sie die Rechtecke malen, können Sie die Überlappungen leicht abfangen.

2
Will
struct Rect
{
   Rect(int x1, int x2, int y1, int y2)
   : x1(x1), x2(x2), y1(y1), y2(y2)
   {
       assert(x1 < x2);
       assert(y1 < y2);
   }

   int x1, x2, y1, y2;
};

//some area of the r1 overlaps r2
bool overlap(const Rect &r1, const Rect &r2)
{
    return r1.x1 < r2.x2 && r2.x1 < r1.x2 &&
           r1.y1 < r2.y2 && r2.x1 < r1.y2;
}

//either the rectangles overlap or the edges touch
bool touch(const Rect &r1, const Rect &r2)
{
    return r1.x1 <= r2.x2 && r2.x1 <= r1.x2 &&
           r1.y1 <= r2.y2 && r2.x1 <= r1.y2;
}
2
Adam Tegen

Nehmen wir an, die zwei Rechtecke sind Rechteck A und Rechteck B. Es seien die Zentren A1 und B1 (die Koordinaten von A1 und B1 können leicht herausgefunden werden), seien die Höhen Ha und Hb, die Breite sei Wa und Wb, sei dx das Breite (x) Abstand zwischen A1 und B1 und dy die Höhe (y) Abstand zwischen A1 und B1.

Jetzt können wir sagen, dass wir A und B überlappen können: wann

if(!(dx > Wa+Wb)||!(dy > Ha+Hb)) returns true
1
sachinr

Der einfachste Weg ist

/**
 * Check if two rectangles collide
 * x_1, y_1, width_1, and height_1 define the boundaries of the first rectangle
 * x_2, y_2, width_2, and height_2 define the boundaries of the second rectangle
 */
boolean rectangle_collision(float x_1, float y_1, float width_1, float height_1, float x_2, float y_2, float width_2, float height_2)
{
  return !(x_1 > x_2+width_2 || x_1+width_1 < x_2 || y_1 > y_2+height_2 || y_1+height_1 < y_2);
}

denken Sie zunächst einmal daran, dass das Koordinatensystem in Computern auf dem Kopf steht. Die x-Achse ist die gleiche wie in der Mathematik, aber die y-Achse steigt nach unten und nimmt mit dem Aufwärtsabstieg ab ... _. dann bedeutet es, dass sie zur Hälfte gehen, sich berühren. und auf dieselbe Weise abwärts + die Hälfte seiner Höhe. es wird kollidieren ..

1
Xar E Ahmer

Denken Sie nicht an Koordinaten, um anzuzeigen, wo sich Pixel befinden. Stellen Sie sich vor, sie befinden sich zwischen den Pixeln. Auf diese Weise sollte die Fläche eines 2x2-Rechtecks ​​4 sein, nicht 9.

bool bOverlap = !((A.Left >= B.Right || B.Left >= A.Right)
               && (A.Bottom >= B.Top || B.Bottom >= A.Top));
1
Mike Dunlavey

Für diejenigen von Ihnen, die Mittelpunkt- und Halbgrößen für ihre Rechteckdaten verwenden, anstelle der typischen Werte für x, y, w, h oder x0, y0, x1, x1, können Sie Folgendes tun:

#include <cmath> // for fabsf(float)

struct Rectangle
{
    float centerX, centerY, halfWidth, halfHeight;
};

bool isRectangleOverlapping(const Rectangle &a, const Rectangle &b)
{
    return (fabsf(a.centerX - b.centerX) <= (a.halfWidth + b.halfWidth)) &&
           (fabsf(a.centerY - b.centerY) <= (a.halfHeight + b.halfHeight)); 
}
0
mchiasson

A und B sind zwei Rechtecke. C sei ihr abdeckendes Rechteck. 

four points of A be (xAleft,yAtop),(xAleft,yAbottom),(xAright,yAtop),(xAright,yAbottom)
four points of A be (xBleft,yBtop),(xBleft,yBbottom),(xBright,yBtop),(xBright,yBbottom)

A.width = abs(xAleft-xAright);
A.height = abs(yAleft-yAright);
B.width = abs(xBleft-xBright);
B.height = abs(yBleft-yBright);

C.width = max(xAleft,xAright,xBleft,xBright)-min(xAleft,xAright,xBleft,xBright);
C.height = max(yAtop,yAbottom,yBtop,yBbottom)-min(yAtop,yAbottom,yBtop,yBbottom);

A and B does not overlap if
(C.width >= A.width + B.width )
OR
(C.height >= A.height + B.height) 

Es kümmert sich um alle möglichen Fälle.

0
Anwit

Diese Antwort sollte die beste sein:

Wenn sich die Rechtecke überlappen, ist der Überlappungsbereich größer als Null. Lassen Sie uns nun den Überlappungsbereich finden:

Wenn sie sich überlappen, ist die linke Kante von Überlappungsrichtig die max(r1.x1, r2.x1) und die rechte Kante die min(r1.x2, r2.x2). Die Länge der Überlappung ist also min(r1.x2, r2.x2) - max(r1.x1, r2.x1)

Das Gebiet wird also sein:

area = (max(r1.x1, r2.x1) - min(r1.x2, r2.x2)) * (max(r1.y1, r2.y1) - min(r1.y2, r2.y2))

Wenn area = 0, überlappen sie sich nicht.

Einfach, nicht wahr?

0
anony

Ich habe eine C # -Version implementiert, die leicht in C++ konvertiert werden kann.

public bool Intersects ( Rectangle rect )
{
  float ulx = Math.Max ( x, rect.x );
  float uly = Math.Max ( y, rect.y );
  float lrx = Math.Min ( x + width, rect.x + rect.width );
  float lry = Math.Min ( y + height, rect.y + rect.height );

  return ulx <= lrx && uly <= lry;
}
0
baretta

Ich habe eine sehr einfache Lösung

sei x1, y1 x2, y2, l1, b1, l2 Koordinaten und Längen und Breiten von diesen

beachte die Bedingung ((x2

jetzt überlappen sich diese Rechtecke nur, wenn der Punkt diagonal zu x1, y1 innerhalb des anderen Rechtecks ​​liegt oder in ähnlicher Weise der Punkt diagonal zu x2, y2 innerhalb des anderen Rechtecks ​​liegt. Das ist genau die obige Bedingung.

0
himanshu

Ein Blick auf die Angelegenheit von einer anderen Seite.

Der Fall stellt sich heraus um ganz einfach zu sein, wenn wir das Problem (Algorithmus) von der anderen Seite betrachten.

Anstatt die Frage zu beantworten: "Überlappen sich die Rechtecke?", Werden wir die Frage beantworten: "Überlappen die Rechtecke nicht?".

Am Ende lösen beide Fragen dasselbe Problem, aber die Antwort auf die zweite Frage ist einfacher zu implementieren, weil Rechtecke nicht nur überlappen, wenn einer unter dem anderen ist oder wenn sich mehr links befindet von dem anderen(es genügt für einen dieser Fälle, aber es kann natürlich vorkommen, dass beide gleichzeitig auftreten - hier ist ein gutes Verständnis der logischen Bedingung "oder" wichtig). Dies reduziert viele Fälle, die bei der ersten Frage berücksichtigt werden müssen.

Die ganze Sache ist auch vereinfacht durch die Verwendung entsprechender Variablennamen:

#include<bits/stdc++.h> 

struct Rectangle
{ 
    // Coordinates of the top left corner of the rectangle and width and height
    float x, y, width, height; 
}; 

bool areRectanglesOverlap(Rectangle rect1, Rectangle rect2) 
{
  // Declaration and initialization of local variables

  // if x and y are the top left corner of the rectangle
  float left1, top1, right1, bottom1, left2, top2, right2, bottom2;
  left1 = rect1.x;
  top1 = rect1.y;
  right1 = rect1.x + rect1.width;
  bottom1 = rect1.y - rect1.height;
  left2 = rect2.x;
  top2 = rect2.y;
  right2 = rect2.x + rect2.width;
  bottom2 = rect2.y - rect2.height;

  // The main part of the algorithm

  // The first rectangle is under the second or vice versa
  if (top1 < bottom2 || top2 < bottom1)
  {
    return false;
  }
  // The first rectangle is to the left of the second or vice versa
  if (right1 < left2 || right2 < left1)
  {
    return false;
  }
  // Rectangles overlap
  return true;
}

Auch Bei einer anderen Darstellung eines Rechtecks ​​ist es einfach, die obige Funktion daran anzupassen, indem nur der Abschnitt geändert wird, in dem die Variablen geändert werden. Der weitere Teil der Funktion bleibt unverändert (natürlich Die Kommentare werden hier nicht wirklich benötigt, aber ich habe sie hinzugefügt, damit jeder diesen einfachen Algorithmus schnell verstehen kann.

Ein Äquivalent, aber möglicherweise etwas weniger lesbar Form der obigen Funktion kann folgendermaßen aussehen:

bool areRectanglesOverlap(Rectangle rect1, Rectangle rect2) 
{
  float left1, top1, right1, bottom1, left2, top2, right2, bottom2;
  left1 = rect1.x;
  top1 = rect1.y;
  right1 = rect1.x + rect1.width;
  bottom1 = rect1.y - rect1.height;
  left2 = rect2.x;
  top2 = rect2.y;
  right2 = rect2.x + rect2.width;
  bottom2 = rect2.y - rect2.height;

  return !(top1 < bottom2 || top2 < bottom1 || right1 < left2 || right2 < left1);
}
0
simhumileco
bool Square::IsOverlappig(Square &other)
{
    bool result1 = other.x >= x && other.y >= y && other.x <= (x + width) && other.y <= (y + height); // other's top left falls within this area
    bool result2 = other.x >= x && other.y <= y && other.x <= (x + width) && (other.y + other.height) <= (y + height); // other's bottom left falls within this area
    bool result3 = other.x <= x && other.y >= y && (other.x + other.width) <= (x + width) && other.y <= (y + height); // other's top right falls within this area
    bool result4 = other.x <= x && other.y <= y && (other.x + other.width) >= x && (other.y + other.height) >= y; // other's bottom right falls within this area
    return result1 | result2 | result3 | result4;
}
0
Kok How Teh

Dies ist aus Übung 3.28 aus dem Buch Einführung in Java Programming Comprehensive Edition. Der Code prüft, ob es sich bei den beiden Rechtecken um Indentikel handelt, ob eines innerhalb des anderen ist und ob eines außerhalb des anderen ist. Wenn keine dieser Bedingungen erfüllt ist, überlappen sich die beiden.

** 3.28 (Geometrie: zwei Rechtecke) Schreiben Sie ein Programm, das den Benutzer zur Eingabe der x-, y-Koordinaten, Breite und Höhe von Center und der Höhe von zwei Rechtecken auffordert, und bestimmt .__, ob das zweite Rechteck innerhalb des ersten liegt oder überlappt sich mit dem ersten, wie in Abbildung 3.9 gezeigt Testen Sie Ihr Programm, um alle Fälle abzudecken. Hier sind die Beispielläufe:

Geben Sie die x-, y-Koordinaten, Breite und Höhe des Mittelpunkts von r1 ein: 2.5 4 2.5 43 Geben Sie die x-, y-Koordinaten, Breite und Höhe des Mittelpunkts von r1 ein: 1,5 5 0,5 3 R2 befindet sich innerhalb von r1 

Geben Sie die x-, y-Koordinaten, Breite und Höhe von r1 ein: 1 2 3 5.5 Geben Sie x-, y-Koordinaten, Breite und Höhe von r2 ein: 3 4 4,5 5 R2 überlappt r1

Geben Sie die x-, y-Koordinaten, Breite und Höhe von r1 ein: 1 2 3 3 Geben Sie die x-, y-Koordinaten, Breite und Höhe von r2 ein: 40 45 3 2 R2 überlappt nicht r1

import Java.util.Scanner;

public class ProgrammingEx3_28 {
public static void main(String[] args) {
    Scanner input = new Scanner(System.in);

    System.out
            .print("Enter r1's center x-, y-coordinates, width, and height:");
    double x1 = input.nextDouble();
    double y1 = input.nextDouble();
    double w1 = input.nextDouble();
    double h1 = input.nextDouble();
    w1 = w1 / 2;
    h1 = h1 / 2;
    System.out
            .print("Enter r2's center x-, y-coordinates, width, and height:");
    double x2 = input.nextDouble();
    double y2 = input.nextDouble();
    double w2 = input.nextDouble();
    double h2 = input.nextDouble();
    w2 = w2 / 2;
    h2 = h2 / 2;

    // Calculating range of r1 and r2
    double x1max = x1 + w1;
    double y1max = y1 + h1;
    double x1min = x1 - w1;
    double y1min = y1 - h1;
    double x2max = x2 + w2;
    double y2max = y2 + h2;
    double x2min = x2 - w2;
    double y2min = y2 - h2;

    if (x1max == x2max && x1min == x2min && y1max == y2max
            && y1min == y2min) {
        // Check if the two are identicle
        System.out.print("r1 and r2 are indentical");

    } else if (x1max <= x2max && x1min >= x2min && y1max <= y2max
            && y1min >= y2min) {
        // Check if r1 is in r2
        System.out.print("r1 is inside r2");
    } else if (x2max <= x1max && x2min >= x1min && y2max <= y1max
            && y2min >= y1min) {
        // Check if r2 is in r1
        System.out.print("r2 is inside r1");
    } else if (x1max < x2min || x1min > x2max || y1max < y2min
            || y2min > y1max) {
        // Check if the two overlap
        System.out.print("r2 does not overlaps r1");
    } else {
        System.out.print("r2 overlaps r1");
    }

}
}
0
anchan42