Algoritmo per rilevare l'intersezione di due rettangoli?

Sto cercando un algoritmo per rilevare se due rettangoli si intersecano (uno con un angolo arbitrario, l'altro con solo linee verticali / orizzontali).

Verifica se un angolo di uno è nell'altro QUASI funziona. Non riesce se i rettangoli formano una forma a croce.

Sembra una buona idea evitare di usare le pendenze delle linee, il che richiederebbe casi speciali per le linee verticali.

Il metodo standard sarebbe quello di eseguire il test dell'asse di separazione (esegui una ricerca su Google).

In breve:

• Due oggetti non si intersecano se riesci a trovare una linea che separa i due oggetti. ad es. gli oggetti / tutti i punti di un oggetto si trovano su lati diversi della linea.

La cosa divertente è che è sufficiente controllare tutti i bordi dei due rettangoli. Se i rettangoli non si sovrappongono, uno dei bordi sarà l'asse di separazione.

In 2D puoi farlo senza usare le pendenze. Un bordo viene semplicemente definito come la differenza tra due vertici, ad es

  edge = v(n) - v(n-1)

Puoi ottenere una perpendicolare ruotandola di 90 °. In 2D questo è facile come:

  rotated.x = -unrotated.y
  rotated.y =  unrotated.x

Quindi nessuna trigonometria o pendenze coinvolte. Non è neppure richiesta la normalizzazione del vettore in unità di lunghezza.

Se vuoi verificare se un punto si trova su un lato o l'altro della linea, puoi semplicemente usare il punto-prodotto. il cartello ti dirà da che parte stai:

  // rotated: your rotated edge
  // v(n-1) any point from the edge.
  // testpoint: the point you want to find out which side it's on.

  side = sign (rotated.x * (testpoint.x - v(n-1).x) + 
               rotated.y * (testpoint.y - v(n-1).y);

Ora prova tutti i punti del rettangolo A contro i bordi del rettangolo B e viceversa. Se trovi un bordo di separazione, gli oggetti non si intersecano (a condizione che tutti gli altri punti in B si trovino sull'altro lato del bordo da testare, vedi disegno sotto). Se non trovi alcun bordo di separazione, i rettangoli si intersecano o un rettangolo è contenuto nell'altro.

Il test funziona con qualsiasi poligono convesso tra il ..

Emendamento: per identificare un bordo di separazione, non è sufficiente testare tutti i punti di un rettangolo rispetto a ciascun bordo dell'altro. Il bordo candidato E (sotto) verrebbe quindi identificato come bordo di separazione, poiché tutti i punti in A si trovano nello stesso semipiano di E. Tuttavia, non è un bordo di separazione perché i vertici Vb1 e Vb2 di B sono anche in quel mezzo piano. Sarebbe stato un vantaggio se non fosse stato il caso http://www.iassess.com/collision.png

Fondamentalmente guarda la seguente immagine:

Se le due caselle si scontrano, le linee A e B si sovrapporranno.

Si noti che questo dovrà essere fatto su entrambi gli assi X e Y, ed entrambi devono sovrapporsi affinché i rettangoli si scontrino.

C'è un buon articolo su gamasutra.com che risponde alla domanda (l'immagine è dall'articolo). Ho fatto un algoritmo simile 5 anni fa e devo trovare il mio frammento di codice per pubblicarlo qui in seguito

Emendamento : il teorema dell'asse di separazione afferma che due forme convesse non si sovrappongono se esiste un asse di separazione (cioè uno in cui le sporgenze mostrate non si sovrappongono). Quindi "Esiste un asse di separazione" => "Nessuna sovrapposizione". Questa non è una doppia implicazione, quindi non puoi concludere il contrario.

La risposta di m_pGladiator è giusta e preferisco. Il test dell'asse di separazione è il metodo più semplice e standard per rilevare la sovrapposizione del rettangolo. Una linea per la quale gli intervalli di proiezione non si sovrappongono si chiama asse di separazione . La soluzione di Nils Pipenbrinck è troppo generica. Usa il prodotto punto per verificare se una forma è totalmente su un lato del bordo dell'altra. Questa soluzione potrebbe effettivamente indurre poligoni convessi n-edge. Tuttavia, non è ottimizzato per due rettangoli.

il punto critico della risposta di m_pGladiator è che dovremmo controllare la proiezione di due rettangoli su entrambi gli assi (xey). Se due proiezioni sono sovrapposte, allora potremmo dire che questi due rettangoli sono sovrapposti. Quindi i commenti sopra alla risposta di m_pGladiator sono sbagliati.

per la semplice situazione, se due rettangoli non vengono ruotati, presentiamo un rettangolo con struttura:

struct Rect {
    x, // the center in x axis
    y, // the center in y axis
    width,
    height
}

chiamiamo rettangolo A, B con rectA, rectB.

    if Math.abs(rectA.x - rectB.x) < (Math.abs(rectA.width + rectB.width) / 2) 
&& (Math.abs(rectA.y - rectB.y) < (Math.abs(rectA.height + rectB.height) / 2))
    then
        // A and B collide
    end if

se uno dei due rettangoli viene ruotato, potrebbero essere necessari alcuni sforzi per determinarne la proiezione sugli assi xey. Definisci struct RotatedRect come segue:

struct RotatedRect : Rect {
    double angle; // the rotating angle oriented to its center
}

la differenza è come la larghezza 'è ora un po' diversa: larghezzaA 'per rectA: Math.sqrt(rectA.width*rectA.width + rectA.height*rectA.height) * Math.cos(rectA.angle) larghezzaB' per rectB:Math.sqrt(rectB.width*rectB.width + rectB.height*rectB.height) * Math.cos(rectB.angle)

    if Math.abs(rectA.x - rectB.x) < (Math.abs(widthA' + widthB') / 2) 
&& (Math.abs(rectA.y - rectB.y) < (Math.abs(heightA' + heightB') / 2))
    then
        // A and B collide
    end if

Potrebbe fare riferimento a un PPT GDC (Game Development Conference 2007) www.realtimecollisiondetection.net/pubs/GDC07_Ericson_Physics_Tutorial_SAT.ppt

In Cocoa potresti facilmente rilevare se il rettangolo dell'Area selezionato interseca il rettangolo del fotogramma NSView ruotato. Non hai nemmeno bisogno di calcolare poligoni, normali e simili. Basta aggiungere questi metodi alla sottoclasse NSView. Ad esempio, l'utente seleziona un'area sulla superview di NSView, quindi si chiama il metodo DoesThisRectSelectMe passando il rrearea selezionata. L'API convertRect: farà quel lavoro. Lo stesso trucco funziona quando si fa clic su NSView per selezionarlo. In tal caso è sufficiente sostituire il metodo hitTest come di seguito. L'API convertPoint: farà quel lavoro ;-)

- (BOOL)DoesThisRectSelectMe:(NSRect)selectedArea
{
    NSRect localArea = [self convertRect:selectedArea fromView:self.superview];

    return NSIntersectsRect(localArea, self.bounds);
}


- (NSView *)hitTest:(NSPoint)aPoint
{
    NSPoint localPoint = [self convertPoint:aPoint fromView:self.superview];
    return NSPointInRect(localPoint, self.bounds) ? self : nil;
}

Controlla se una delle linee di un rettangolo interseca una delle linee dell'altro. L'intersezione del segmento di linea ingenua è facile da codificare.

Se è necessaria una maggiore velocità, esistono algoritmi avanzati per l'intersezione del segmento di linea (sweep-line). Vedi http://en.wikipedia.org/wiki/Line_segment_intersection

Una soluzione è utilizzare qualcosa chiamato poligono No Fit. Questo poligono viene calcolato dai due poligoni (concettualmente facendo scorrere l'uno attorno all'altro) e definisce l'area per la quale i poligoni si sovrappongono dato il loro offset relativo. Una volta che hai questo NFP, devi semplicemente fare un test di inclusione con un punto dato dall'offset relativo dei due poligoni. Questo test di inclusione è semplice e veloce ma devi prima creare l'NFP.

Cerca un poligono No Fit sul Web e vedi se riesci a trovare un algoritmo per poligoni convessi (diventa MOLTO più complesso se hai poligoni concavi). Se non riesci a trovare nulla, inviami un'e-mail all'indirizzo howard dot J dot potrebbe gmail dot com

Ecco cosa penso si occuperà di tutti i casi possibili. Fai i seguenti test.

1. Controllare uno dei vertici del rettangolo 1 risiedere all'interno del rettangolo 2 e viceversa. Ogni volta che trovi un vertice che risiede all'interno dell'altro rettangolo puoi concludere che si intersecano e fermano la ricerca. Questo si occuperà di un rettangolo che risiede completamente all'interno dell'altro.
2. Se il test sopra riportato non è conclusivo, trova i punti di intersezione di ciascuna linea di 1 rettangolo con ciascuna linea dell'altro rettangolo. Una volta trovato un punto di intersezione, controlla se risiede all'interno del rettangolo immaginario creato dai corrispondenti 4 punti. Ogni volta che si trova un punto del genere, concludere che si intersecano e interrompono la ricerca.

Se i 2 test precedenti restituiscono false, questi 2 rettangoli non si sovrappongono.

Se stai usando Java, tutte le implementazioni dell'interfaccia Shape hanno un metodo intersects che prende un rettangolo.

Bene, il metodo della forza bruta è di camminare sui bordi del rettangolo orizzontale e controllare ogni punto lungo il bordo per vedere se cade o nell'altro rettangolo.

La risposta matematica è formare equazioni che descrivono ciascun bordo di entrambi i rettangoli. Ora puoi semplicemente trovare se una delle quattro linee del rettangolo A interseca una delle linee del rettangolo B, che dovrebbe essere un semplice (veloce) risolutore di equazioni lineari.

-Adamo

È possibile trovare l'intersezione di ciascun lato del rettangolo angolato con ciascun lato di quello allineato agli assi. Fallo trovando l'equazione della linea infinita su cui si trova ciascun lato (cioè v1 + t (v2-v1) e v'1 + t '(v'2-v'1) fondamentalmente), trovando il punto in cui il le linee si incontrano risolvendo t quando queste due equazioni sono uguali (se sono parallele, è possibile verificarle) e quindi testando se quel punto si trova sul segmento di linea tra i due vertici, cioè è vero che 0 <= t <= 1 e 0 <= t '<= 1.

Tuttavia, questo non copre il caso in cui un rettangolo copre completamente l'altro. Che puoi coprire verificando se tutti e quattro i punti di entrambi i rettangoli si trovano all'interno dell'altro rettangolo.

Questo è quello che farei, per la versione 3D di questo problema:

Modella i 2 rettangoli come piani descritti dall'equazione P1 e P2, quindi scrivi P1 = P2 e deriva da quella linea di equazione di intersezione, che non esisterà se i piani sono paralleli (nessuna intersezione) o si trovano sullo stesso piano, nel qual caso ottieni 0 = 0. In tal caso dovrai utilizzare un algoritmo di intersezione rettangolo 2D.

Quindi vedrei se quella linea, che si trova sul piano di entrambi i rettangoli, passa attraverso entrambi i rettangoli. In tal caso, hai un'intersezione di 2 rettangoli, altrimenti non lo fai (o non dovrei, potrei essermi perso un caso ad angolo nella mia testa).

Per scoprire se una linea passa attraverso un rettangolo sullo stesso piano, troverei i 2 punti di intersezione della linea e i lati del rettangolo (modellandoli usando le equazioni di linea), e quindi assicurarmi che i punti di intersezione siano con in gamma.

Queste sono le descrizioni matematiche, sfortunatamente non ho un codice per fare quanto sopra.

Un altro modo di eseguire il test, che è leggermente più veloce rispetto all'utilizzo del test dell'asse di separazione, è utilizzare l'algoritmo dei numeri di avvolgimento (solo sui quadranti - non la somma degli angoli che è orribilmente lento) su ciascun vertice di uno dei rettangoli (scelto arbitrariamente). Se uno qualsiasi dei vertici ha un numero di avvolgimento diverso da zero, i due rettangoli si sovrappongono.

Questo algoritmo è un po 'più lungo rispetto al test dell'asse di separazione, ma è più veloce perché richiede un test sul semipiano solo se i bordi attraversano due quadranti (al contrario di un massimo di 32 test con il metodo dell'asse di separazione)

L'algoritmo ha l'ulteriore vantaggio di poter essere utilizzato per testare la sovrapposizione di qualsiasi poligono (convesso o concavo). Per quanto ne so, l'algoritmo funziona solo nello spazio 2D.

O mi manca qualcos'altro perché renderlo così complicato?

se (x1, y1) e (X1, Y1) sono angoli dei rettangoli, quindi per trovare l'intersezione fai:

    xIntersect = false;
    yIntersect = false;
    if (!(Math.min(x1, x2, x3, x4) > Math.max(X1, X2, X3, X4) || Math.max(x1, x2, x3, x4) < Math.min(X1, X2, X3, X4))) xIntersect = true;
    if (!(Math.min(y1, y2, y3, y4) > Math.max(Y1, Y2, Y3, Y4) || Math.max(y1, y2, y3, y4) < Math.min(Y1, Y2, Y3, Y4))) yIntersect = true;
    if (xIntersect && yIntersect) {alert("Intersect");}

L'ho implementato in questo modo:

bool rectCollision(const CGRect &boundsA, const Matrix3x3 &mB, const CGRect &boundsB)
{
    float Axmin = boundsA.origin.x;
    float Axmax = Axmin + boundsA.size.width;
    float Aymin = boundsA.origin.y;
    float Aymax = Aymin + boundsA.size.height;

    float Bxmin = boundsB.origin.x;
    float Bxmax = Bxmin + boundsB.size.width;
    float Bymin = boundsB.origin.y;
    float Bymax = Bymin + boundsB.size.height;

    // find location of B corners in A space
    float B0x = mB(0,0) * Bxmin + mB(0,1) * Bymin + mB(0,2);
    float B0y = mB(1,0) * Bxmin + mB(1,1) * Bymin + mB(1,2);

    float B1x = mB(0,0) * Bxmax + mB(0,1) * Bymin + mB(0,2);
    float B1y = mB(1,0) * Bxmax + mB(1,1) * Bymin + mB(1,2);

    float B2x = mB(0,0) * Bxmin + mB(0,1) * Bymax + mB(0,2);
    float B2y = mB(1,0) * Bxmin + mB(1,1) * Bymax + mB(1,2);

    float B3x = mB(0,0) * Bxmax + mB(0,1) * Bymax + mB(0,2);
    float B3y = mB(1,0) * Bxmax + mB(1,1) * Bymax + mB(1,2);

    if(B0x<Axmin && B1x<Axmin && B2x<Axmin && B3x<Axmin)
        return false;
    if(B0x>Axmax && B1x>Axmax && B2x>Axmax && B3x>Axmax)
        return false;
    if(B0y<Aymin && B1y<Aymin && B2y<Aymin && B3y<Aymin)
        return false;
    if(B0y>Aymax && B1y>Aymax && B2y>Aymax && B3y>Aymax)
        return false;

    float det = mB(0,0)*mB(1,1) - mB(0,1)*mB(1,0);
    float dx = mB(1,2)*mB(0,1) - mB(0,2)*mB(1,1);
    float dy = mB(0,2)*mB(1,0) - mB(1,2)*mB(0,0);

    // find location of A corners in B space
    float A0x = (mB(1,1) * Axmin - mB(0,1) * Aymin + dx)/det;
    float A0y = (-mB(1,0) * Axmin + mB(0,0) * Aymin + dy)/det;

    float A1x = (mB(1,1) * Axmax - mB(0,1) * Aymin + dx)/det;
    float A1y = (-mB(1,0) * Axmax + mB(0,0) * Aymin + dy)/det;

    float A2x = (mB(1,1) * Axmin - mB(0,1) * Aymax + dx)/det;
    float A2y = (-mB(1,0) * Axmin + mB(0,0) * Aymax + dy)/det;

    float A3x = (mB(1,1) * Axmax - mB(0,1) * Aymax + dx)/det;
    float A3y = (-mB(1,0) * Axmax + mB(0,0) * Aymax + dy)/det;

    if(A0x<Bxmin && A1x<Bxmin && A2x<Bxmin && A3x<Bxmin)
        return false;
    if(A0x>Bxmax && A1x>Bxmax && A2x>Bxmax && A3x>Bxmax)
        return false;
    if(A0y<Bymin && A1y<Bymin && A2y<Bymin && A3y<Bymin)
        return false;
    if(A0y>Bymax && A1y>Bymax && A2y>Bymax && A3y>Bymax)
        return false;

    return true;
}

La matrice mB è qualsiasi matrice di trasformazione affine che converte i punti nello spazio B in punti nello spazio A. Ciò include rotazione e traslazione semplici, rotazione più ridimensionamento e orditi affini completi, ma non orditi prospettici.

Potrebbe non essere il più ottimale possibile. La velocità non era una grande preoccupazione. Tuttavia sembra funzionare bene per me.

Ecco un'implementazione matlab della risposta accettata:

function olap_flag = ol(A,B,sub)

%A and B should be 4 x 2 matrices containing the xy coordinates of the corners in clockwise order

if nargin == 2
  olap_flag = ol(A,B,1) && ol(B,A,1);
  return;
end

urdl = diff(A([1:4 1],:));
s = sum(urdl .* A, 2);
sdiff = B * urdl' - repmat(s,[1 4]);

olap_flag = ~any(max(sdiff)<0);

Questo è il metodo convenzionale, vai riga per riga e controlla se le linee si intersecano. Questo è il codice in MATLAB.

C1 = [0, 0];    % Centre of rectangle 1 (x,y)
C2 = [1, 1];    % Centre of rectangle 2 (x,y)
W1 = 5; W2 = 3; % Widths of rectangles 1 and 2
H1 = 2; H2 = 3; % Heights of rectangles 1 and 2
% Define the corner points of the rectangles using the above
R1 = [C1(1) + [W1; W1; -W1; -W1]/2, C1(2) + [H1; -H1; -H1; H1]/2];
R2 = [C2(1) + [W2; W2; -W2; -W2]/2, C2(2) + [H2; -H2; -H2; H2]/2];

R1 = [R1 ; R1(1,:)] ;
R2 = [R2 ; R2(1,:)] ;

plot(R1(:,1),R1(:,2),'r')
hold on
plot(R2(:,1),R2(:,2),'b')


%% lines of Rectangles 
L1 = [R1(1:end-1,:) R1(2:end,:)] ;
L2 = [R2(1:end-1,:) R2(2:end,:)] ;
%% GEt intersection points
P = zeros(2,[]) ;
count = 0 ;
for i = 1:4
    line1 = reshape(L1(i,:),2,2) ;
    for j = 1:4
        line2 = reshape(L2(j,:),2,2) ;
        point = InterX(line1,line2) ;
        if ~isempty(point)
            count = count+1 ;
            P(:,count) = point ;
        end
    end
end
%%
if ~isempty(P)
    fprintf('Given rectangles intersect at %d points:\n',size(P,2))
    plot(P(1,:),P(2,:),'*k')
end

la funzione InterX può essere scaricata da: https://in.mathworks.com/matlabcentral/fileexchange/22441-curve-intersections?focused=5165138&tab=function

Ho un metodo più semplice per me, se abbiamo 2 rettangoli:

R1 = (min_x1, max_x1, min_y1, max_y1)

R2 = (min_x2, max_x2, min_y2, max_y2)

Si sovrappongono se e solo se:

Sovrapposizione = (max_x1> min_x2) e (max_x2> min_x1) e (max_y1> min_y2) e (max_y2> min_y1)

Puoi farlo anche per scatole 3D, in realtà funziona per qualsiasi numero di dimensioni.

È stato detto abbastanza in altre risposte, quindi aggiungerò uno pseudocodice one-liner:

!(a.left > b.right || b.left > a.right || a.top > b.bottom || b.top > a.bottom);