Determinare se due rettangoli si sovrappongono?


337

Sto cercando di scrivere un programma C ++ che prende i seguenti input dall'utente per costruire rettangoli (tra 2 e 5): altezza, larghezza, x-pos, y-pos. Tutti questi rettangoli esisteranno paralleli all'asse xe y, ovvero tutti i loro bordi avranno pendenze di 0 o infinito.

Ho cercato di attuare quanto menzionato in questa domanda ma non ho molta fortuna.

La mia attuale implementazione fa quanto segue:

// 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;  

Tuttavia non sono del tutto sicuro se (a) ho implementato l'algoritmo a cui ho collegato correttamente o se ho fatto esattamente come interpretarlo?

Eventuali suggerimenti?


3
penso che la soluzione al tuo problema non implichi alcuna moltiplicazione.
Scott Evernden,

Risposte:


708
if (RectA.Left < RectB.Right && RectA.Right > RectB.Left &&
     RectA.Top > RectB.Bottom && RectA.Bottom < RectB.Top ) 

oppure, usando le coordinate cartesiane

(Con X1 a sinistra coord, X2 a destra coord, aumentando da sinistra a destra e Y1 come top coord, e Y2 come bottom coord, aumentando dal basso verso l'alto - se non è così che il tuo sistema di coordinate [es. La maggior parte dei computer ha il Direzione Y invertita], scambia i confronti di seguito ) ...

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

Supponi di avere il Rect A e il Rect B. La prova è per contraddizione. Una delle quattro condizioni garantisce che non possa esistere sovrapposizione :

  • COND1. Se il bordo sinistro di A è a destra del bordo destro di B, - allora A è Totalmente a destra di B
  • Cond2. Se il bordo destro di A è a sinistra del bordo sinistro di B, allora A è totalmente a sinistra di B
  • Cond3. Se il bordo superiore di A è sotto il bordo inferiore di B, allora A è totalmente sotto B
  • Cond4. Se il bordo inferiore di A è sopra il bordo superiore di B, allora A è totalmente sopra B

Quindi è condizione per non sovrapposizione

NON-Overlap => Cond1 o Cond2 o Cond3 o Cond4

Pertanto, una condizione sufficiente per la sovrapposizione è l'opposto.

Sovrapposizione => NOT (Cond1 o Cond2 o Cond3 o Cond4)

La legge di De Morgan dice che
Not (A or B or C or D)è la stessa cosa che Not A And Not B And Not C And Not D
usando De Morgan, abbiamo

Non Cond1 E Non Cond2 E Non Cond3 E Non Cond4

Ciò equivale a:

  • Bordo sinistro di A a sinistra del bordo destro di B, [RectA.Left < RectB.Right ] e
  • Il bordo destro di A a destra del bordo sinistro di B, [RectA.Right > RectB.Left ] e
  • A in alto sopra B in basso, [RectA.Top > RectB.Bottom ] e
  • Parte inferiore di A sotto la parte superiore di B [ RectA.Bottom < RectB.Top]

Nota 1 : è abbastanza ovvio che questo stesso principio può essere esteso a qualsiasi numero di dimensioni.
Nota 2 : Dovrebbe anche essere abbastanza ovvio contare le sovrapposizioni di un solo pixel, cambiare <e e / o il >limite su a <=o a >=.
Nota 3 : questa risposta, quando si utilizzano le coordinate cartesiane (X, Y) si basa sulle coordinate cartesiane algebriche standard (x aumenta da sinistra a destra e Y aumenta dal basso verso l'alto). Ovviamente, laddove un sistema informatico potrebbe meccanizzare le coordinate dello schermo in modo diverso (ad esempio, aumentando Y dall'alto verso il basso o X da destra a sinistra), la sintassi dovrà essere regolata di conseguenza /


489
Se hai difficoltà a visualizzare il motivo per cui funziona, ho creato una pagina di esempio su silentmatt.com/intersection.html in cui puoi trascinare i rettangoli e vedere i confronti.
Matthew Crumley,

4
non pensi di usare i vincoli forti? cosa succede se i due rettangoli si sovrappongono esattamente sul bordo? non dovresti considerare <=,> = ??
Nawshad Farruque,

6
@MatthewCrumley per A.Y1 <B.Y2 e A.Y2> B.Y1 sul tuo link, i segni gt & lt non dovrebbero essere invertiti?
NikT

15
Ho dovuto scambiare <e> negli ultimi due confronti per farlo funzionare
DataGreed

17
No, la risposta è corretta come indicato. Si basa sull'uso delle coordinate cartesiane standard. Se si utilizza un sistema diverso, (Y aumenta dall'alto verso il basso), quindi apportare le modifiche appropriate.
Charles Bretana,

115
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;
}

15
Risposta più semplice e pulita.
martedì

1
@ e.James Immagino che l'ultimo B.heightdovrebbe essereA.height
mat_boy

'min' e 'max' sono parole chiave riservate in <windows.h>. puoi risolverlo facendo #undef mine #undef max, o usando nomi di parametri diversi.
mchiasson,

Se lo usi ampiamente, puoi scambiare valueInRange con un#define BETWEEN(value,min,max) \ (\ value > max ? max : ( value < min ? min : value )\ )
Ratata Tata

@Nemo In realtà, il controllo xOverlapè in una dimensione; rectOverlapè bidimensionale. Può essere esteso a N dimensioni usando un anello.
Justme0

27
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;
}

Ben fatto! L'applicazione della legge De Morgans ottiene: r1.x1 <= r2.x2 && r2.x1 <= r1.x2 && r1.y1 <= r2.y2 && r2.y1 <= r1.y2.
Borzh

23

È più facile controllare se un rettangolo è completamente fuori dall'altro, quindi se lo è

sulla sinistra...

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

o sulla destra ...

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

o in cima ...

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

o sul fondo ...

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

del secondo rettangolo, non può assolutamente scontrarsi con esso. Quindi per avere una funzione che restituisca un tempo booleano che dice che i rettangoli si scontrano, combiniamo semplicemente le condizioni con OR logici e neghiamo il risultato:

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);
}

Per ricevere già un risultato positivo solo toccando, possiamo cambiare "<" e ">" con "<=" e "> =".


3
E applicare la legge di De Morgan ad esso.
Borzh,

6

Ponetevi la domanda opposta: come posso determinare se due rettangoli non si intersecano affatto? Ovviamente, un rettangolo A completamente a sinistra del rettangolo B non si interseca. Anche se A è completamente a destra. E allo stesso modo se A è completamente sopra B o completamente sotto B. In ogni altro caso A e B si intersecano.

Ciò che segue può avere dei bug, ma sono abbastanza fiducioso dell'algoritmo:

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

Supponiamo di aver definito le posizioni e le dimensioni dei rettangoli in questo modo:

inserisci qui la descrizione dell'immagine

La mia implementazione C ++ è così:

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;
}

Un esempio di chiamata di funzione secondo la figura sopra riportata:

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

I confronti all'interno del ifblocco saranno i seguenti:

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    ))

3

Ecco come viene eseguito nell'API Java:

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));
}

Si noti che in C ++ questi test per l'overflow non funzioneranno, perché l'overflow di numeri interi con segno non è definito.
Ben Voigt,

2

Nella domanda, ti colleghi ai calcoli per quando i rettangoli si trovano ad angoli di rotazione arbitrari. Se capisco comunque la parte relativa agli angoli della domanda, interpreto che tutti i rettangoli sono perpendicolari l'uno all'altro.

Una conoscenza generale dell'area della formula di sovrapposizione è:

Utilizzando l'esempio:

   1 2 3 4 5 6

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

1) raccogliere tutte le coordinate x (sia a destra che a sinistra) in un elenco, quindi ordinarle e rimuovere i duplicati

1 3 4 5 6

2) raccogliere tutte le coordinate y (sia in alto che in basso) in un elenco, quindi ordinarle e rimuovere i duplicati

1 2 3 4 6

3) creare un array 2D per numero di spazi tra le coordinate x uniche * numero di spazi tra le coordinate y uniche.

4 * 4

4) dipingi tutti i rettangoli in questa griglia, aumentando il conteggio di ogni cella su cui si verifica:

   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) Mentre dipingi i rettangoli, è facile intercettare le sovrapposizioni.


2
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;
}

1

Non pensare alle coordinate come a indicare dove sono i pixel. Pensali come se fossero tra i pixel. In questo modo, l'area di un rettangolo 2x2 dovrebbe essere 4, non 9.

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

1

Il modo più semplice è

/**
 * 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);
}

prima di tutto ti viene in mente che nei computer il sistema di coordinate è sottosopra. l'asse x è lo stesso della matematica ma l'asse y aumenta verso il basso e diminuisce andando verso l'alto .. se il rettangolo viene disegnato dal centro. se le coordinate x1 sono maggiori di x2 più la sua metà della larghezza. allora significa che andando a metà si toccheranno. e nello stesso modo scendendo + metà della sua altezza. si scontrerà ..


1

Supponiamo che i due rettangoli siano rettangolo A e rettangolo B. Lasciate che i loro centri siano A1 e B1 (le coordinate di A1 e B1 possono essere facilmente individuate), che le altezze siano Ha e Hb, la larghezza sia Wa e Wb, che dx sia il larghezza (x) distanza tra A1 e B1 e dy altezza (y) distanza tra A1 e B1.

Ora possiamo dire che possiamo dire che A e B si sovrappongono: quando

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

0

Ho implementato una versione C #, è facilmente convertita in C ++.

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;
}

2
Per l'occhio allenato è chiaro che intendevi che questa era una classe di estensione per Rectangle, ma non hai fornito alcun limite o codice per farlo effettivamente. Sarebbe bello se lo avessi fatto o spiegato così come dovrebbe essere usato il tuo metodo, e punti bonus se le tue variabili avessero effettivamente nomi abbastanza descrittivi per chiunque lo seguisse per capire il loro scopo / intenzione.
tpartee

0

Ho una soluzione molto semplice

lascia che x1, y1 x2, y2, l1, b1, l2 siano rispettivamente coordinate e lunghezze e ampiezze

considera la condizione ((x2

ora l'unico modo in cui questi rettangoli si sovrapporranno è se il punto diagonale a x1, y1 si troverà all'interno dell'altro rettangolo o allo stesso modo il punto diagonale a x2, y2 si troverà all'interno dell'altro rettangolo. quale è esattamente la condizione di cui sopra implica.


0

A e B sono due rettangoli. C è il loro rettangolo di copertura.

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) 

Si prende cura di tutti i casi possibili.


0

Questo è tratto dall'esercizio 3.28 del libro Introduzione alla programmazione Java - Edizione completa. Il codice verifica se i due rettangoli sono indipendenti, se uno è all'interno dell'altro e se uno è all'esterno dell'altro. Se nessuna di queste condizioni è soddisfatta, le due si sovrappongono.

** 3.28 (Geometria: due rettangoli) Scrivi un programma che richiede all'utente di inserire le coordinate centrali x, y, larghezza e altezza di due rettangoli e determina se il secondo rettangolo si trova all'interno del primo o si sovrappone al primo, come mostrato nella Figura 3.9. Metti alla prova il tuo programma per coprire tutti i casi. Ecco le esecuzioni di esempio:

Inserisci le coordinate x, y, centro di r1, larghezza e altezza: 2,5 4 2,5 43 Inserisci le coordinate x, y, centro di r2, larghezza e altezza: 1,5 5 0,5 3 r2 è all'interno di r1

Inserisci le coordinate x, y, centro di r1, larghezza e altezza: 1 2 3 5.5 Inserisci le coordinate x, y, centro di r2, larghezza e altezza: 3 4 4.5 5 r2 si sovrappone r1

Inserisci le coordinate x, y, centro di r1, larghezza e altezza: 1 2 3 3 Inserisci le coordinate x, y, centro di r2, larghezza e altezza: 40 45 3 2 r2 non si sovrappone a 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
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

Per quelli di voi che usano punti centrali e mezze dimensioni per i loro dati rettangolari, invece dei tipici x, y, w, h o x0, y0, x1, x1, ecco come è possibile farlo:

#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
struct point { int x, y; };

struct rect { point tl, br; }; // top left and bottom right points

// return true if rectangles overlap
bool overlap(const rect &a, const rect &b)
{
    return a.tl.x <= b.br.x && a.br.x >= b.tl.x && 
           a.tl.y >= b.br.y && a.br.y <= b.tl.y;
}

0

Se i rettangoli si sovrappongono, l'area di sovrapposizione sarà maggiore di zero. Ora cerchiamo di trovare l'area di sovrapposizione:

Se si sovrappongono, il bordo sinistro della sovrapposizione sarà il max(r1.x1, r2.x1)bordo destro e quello destro min(r1.x2, r2.x2). Quindi la lunghezza della sovrapposizione saràmin(r1.x2, r2.x2) - max(r1.x1, r2.x1)

Quindi l'area sarà:

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

Se area = 0quindi non si sovrappongono.

Semplice no?


3
Questo funziona per sovrapposizione (che è la domanda) ma non funzionerà per l'intersezione, poiché non funzionerà se si intersecano esattamente in un angolo.
Lance Roberts,

Ho provato questo codice e non funziona affatto. Ricevo solo numeri positivi anche quando non si sovrappongono affatto.
Brett,

@Brett: Sì, perché il prodotto di due numeri negativi è positivo.
Ben Voigt,

@BenVoigt, il problema era che la funzione non restituiva 0 quando non c'era sovrapposizione. Non ero molto chiaro con il mio commento, ma sì, ho sempre ricevuto solo un'area> 0 da questa funzione.
Brett,

Se stai lavorando con numeri in virgola mobile, è generalmente una pessima idea usare sottrazioni e altre cose aritmetiche prima di effettuare confronti tra numeri. Soprattutto se è necessario confrontare con un valore esatto, in questo caso zero. Funziona in teoria, ma non in pratica.
Maja,


-1

Codice Java per capire se i rettangoli si stanno contattando o si sovrappongono

...

for ( int i = 0; i < n; i++ ) {
    for ( int j = 0; j < n; j++ ) {
        if ( i != j ) {
            Rectangle rectangle1 = rectangles.get(i);
            Rectangle rectangle2 = rectangles.get(j);

            int l1 = rectangle1.l; //left
            int r1 = rectangle1.r; //right
            int b1 = rectangle1.b; //bottom
            int t1 = rectangle1.t; //top

            int l2 = rectangle2.l;
            int r2 = rectangle2.r;
            int b2 = rectangle2.b;
            int t2 = rectangle2.t;

            boolean topOnBottom = t2 == b1;
            boolean bottomOnTop = b2 == t1;
            boolean topOrBottomContact = topOnBottom || bottomOnTop;

            boolean rightOnLeft = r2 == l1;
            boolean leftOnRight = l2 == r1;
            boolean rightOrLeftContact = leftOnRight || rightOnLeft;

            boolean leftPoll = l2 <= l1 && r2 >= l1;
            boolean rightPoll = l2 <= r1 && r2 >= r1;
            boolean leftRightInside = l2 >= l1 && r2 <= r1;
            boolean leftRightPossiblePlaces = leftPoll || rightPoll || leftRightInside;

            boolean bottomPoll = t2 >= b1 && b2 <= b1;
            boolean topPoll = b2 <= b1 && t2 >= b1;
            boolean topBottomInside = b2 >= b1 && t2 <= t1;
            boolean topBottomPossiblePlaces = bottomPoll || topPoll || topBottomInside;


            boolean topInBetween = t2 > b1 && t2 < t1;
            boolean bottomInBetween = b2 > b1 && b2 < t1;
            boolean topBottomInBetween = topInBetween || bottomInBetween;

            boolean leftInBetween = l2 > l1 && l2 < r1;
            boolean rightInBetween = r2 > l1 && r2 < r1;
            boolean leftRightInBetween = leftInBetween || rightInBetween;

            if ( (topOrBottomContact && leftRightPossiblePlaces) || (rightOrLeftContact && topBottomPossiblePlaces) ) {
                path[i][j] = true;
            }
        }
    }
}

...

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.