Алгоритм виявлення перетину двох прямокутників?

Я шукаю алгоритм, щоб визначити, чи перетинаються два прямокутники (один під довільним кутом, а другий лише вертикальні / горизонтальні лінії).

Тестування, чи працює кут одного в іншому ALMOST. Він не вдається, якщо прямокутники мають форму хрестоподібної форми.

Здається, гарна ідея уникати використання схилів ліній, що вимагало б особливих випадків для вертикальних ліній.

Стандартним методом було б зробити тест роздільної осі (здійснити пошук в Google).

Коротко:

• Два об'єкти не перетинаються, якщо ви можете знайти лінію, яка розділяє два об'єкти. наприклад, об'єкти / всі точки об'єкта знаходяться на різних сторонах лінії.

Найцікавіше, що достатньо лише перевірити всі краї двох прямокутників. Якщо прямокутники не перетинаються, один з ребер буде осі, що розділяє.

У 2D ви можете це зробити без використання нахилів. Ребро просто визначається як різниця між двома вершинами, наприклад

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

Ви можете отримати перпендикуляр до цього, обертаючи його на 90 °. У 2D це легко так:

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

Тож жодна тригонометрія чи схили не задіяні. Нормалізація вектора на одиницю довжини також не потрібна.

Якщо ви хочете перевірити, чи є точка на тій чи іншій стороні лінії, ви можете просто використовувати крапковий добуток. знак підкаже вам, на якій стороні ви знаходитесь:

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

Тепер протестуйте всі точки прямокутника A по краях прямокутника B і навпаки. Якщо ви знайдете розділовий край, об'єкти не перетинаються (якщо всі інші точки в B знаходяться на іншій стороні краю, на який перевіряється - див. Малюнок нижче). Якщо ви не знайдете відокремлюваного краю, то прямокутники перетинаються, або один прямокутник міститься в іншому.

Тест працює з будь-якими опуклими багатокутниками btw ..

Поправка: Щоб визначити розділовий край, недостатньо протестувати всі точки одного прямокутника проти кожного краю іншого. Край-кандидат E (внизу), як такий, ідентифікується як розділовий край, оскільки всі точки в A знаходяться в одній півплощині E. Однак це не розділювальне ребро, оскільки вершини Vb1 і Vb2 B також знаходяться в тій півплощині. Це було б лише окремим краєм, якби це не було http://www.iassess.com/collision.png

В основному дивіться наступну картинку:

Якщо два поля зіткнуться, лінії А і В будуть перетинатися.

Зауважте, що це доведеться робити як на осі X, так і на Y, і обидві повинні перекриватись для стикання прямокутників.

У gamasutra.com є гарна стаття, яка відповідає на питання (малюнок із статті). Я робив подібний алгоритм 5 років тому, і я повинен знайти свій фрагмент коду, щоб опублікувати його тут пізніше

Поправка : Теорема роздільної осі стверджує, що дві опуклі форми не перетинаються, якщо існує розділююча вісь (тобто така, де проекції, як показано , не перетинаються). Отже, "Відокремлювальна вісь існує" => "Ніякого перекриття". Це не є двозначним, тому ви не можете зробити висновок про зворотне.

m_pGladiator відповідь правильна, і я вважаю за краще це. Тест роздільної осі є найпростішим і стандартним методом виявлення перекриття прямокутника. Рядок, для якого інтервали проекції не перетинаються, називаємо розділовою віссю . Рішення Нілса Піпенбрінка є надто загальним. Він використовує крапковий виріб, щоб перевірити, чи одна форма повністю стоїть на одній стороні краю іншої. Це рішення насправді може спонукати до n-реберних опуклих багатокутників. Однак він не оптимізований для двох прямокутників.

критична точка відповіді m_pGladiator полягає в тому, що ми повинні перевірити проекцію двох прямокутників на обидві осі (x і y). Якщо дві проекції перекриваються, то можна сказати, що ці два прямокутники перекриваються. Отже, коментарі до відповіді m_pGladiator є помилковими.

для простої ситуації, якщо два прямокутника не обертаються, ми представляємо прямокутник зі структурою:

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

назвемо прямокутник A, B з 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

якщо будь-який з двох прямокутників повернутий, то для визначення проекції їх на осі x і y можуть знадобитися певні зусилля. Визначте Stru RotatedRect таким чином:

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

різниця полягає в тому, як ширина 'зараз трохи відрізняється: widthA' для rectA: Math.sqrt(rectA.width*rectA.width + rectA.height*rectA.height) * Math.cos(rectA.angle) widthB 'для 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

Може посилатися на GDC (Game Development Conference 2007) PPT www.realtimecollisiondetection.net/pubs/GDC07_Ericson_Physics_Tutorial_SAT.ppt

У какао ви зможете легко визначити, чи перетинається обрана зона Area переглянуту рамку кадру NSView. Вам навіть не потрібно обчислювати багатокутники, нормальні такі. Просто додайте ці методи до свого підкласу NSView. Наприклад, користувач вибирає область під наглядом NSView, після чого ви викликаєте метод DoesThisRectSelectMe, передаючи обрану дію прямої області. API convertRect: зробить цю роботу. Цей же трюк працює, коли ви натискаєте на NSView, щоб вибрати його. У цьому випадку просто замініть метод hitTest, як показано нижче. API convertPoint: зробить цю роботу ;-)

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

Перевірте, чи перетинає будь-який з ліній одного прямокутника будь-який з інших. Перетин сегмента наївної лінії легко кодувати.

Якщо вам потрібна більша швидкість, існують розширені алгоритми перетину відрізка лінії (розгортка). Дивіться http://en.wikipedia.org/wiki/Line_segment_intersection

Одне рішення - використовувати щось, що називається No Fit Polygon. Цей многокутник обчислюється з двох многокутників (концептуально ковзаючи один навколо іншого) і він визначає площу, на яку багатокутники перекриваються, враховуючи їх відносне зміщення. Після того, як у вас є цей NFP, ви просто повинні зробити тест на включення з точкою, заданою відносним зміщенням двох многокутників. Цей тест на включення швидкий і простий, але вам потрібно створити NFP спочатку.

Пошукайте в Інтернеті No Fit Polygon і подивіться, чи зможете ви знайти алгоритм для опуклих багатокутників (він набагато складніший, якщо у вас є увігнуті багатокутники). Якщо ви нічого не можете знайти, то напишіть мені електронною поштою howard dot J dot, можливо, gmail dot com

Ось що, на мою думку, піклується про всі можливі випадки. Зробіть наступні тести.

1. Перевірте будь-яку вершину прямокутника 1, яка знаходиться всередині прямокутника 2, і навпаки. Щоразу, коли ви знайдете вершину, яка знаходиться всередині іншого прямокутника, ви можете зробити висновок, що вони перетинаються і зупиняють пошук. Це подбає про те, щоб один прямокутник повністю знаходився всередині іншого.
2. Якщо вищевказаний тест є непереконливим, знайдіть точки перетину кожного рядка по 1 прямокутника з кожною лінією іншого прямокутника. Після того, як буде виявлена ​​точка перетину, перевірте, чи знаходиться вона всередині уявного прямокутника, створеного відповідними 4 точками. Коли колись знайдеться така точка, зробіть висновок, що вони перетинаються та зупиняють пошук.

Якщо вищевказані 2 тести повертають помилково, ці 2 прямокутники не перетинаються.

Якщо ви використовуєте Java, всі реалізації інтерфейсу Shape мають метод перетину, який займає прямокутник.

Ну, метод грубої сили полягає в тому, щоб пройтися по краях горизонтального прямокутника і перевірити кожну точку по краю, щоб побачити, чи потрапляє він на другий прямокутник.

Математична відповідь полягає у формуванні рівнянь, що описують кожен край обох прямокутників. Тепер ви можете просто знайти, чи перетинає будь-який із чотирьох прямих прямокутника A будь-який з прямокутників B, який повинен бути простим (швидким) лінійним рівнянням рівняння.

-Адам

Ви можете знайти перетин кожної сторони кутового прямокутника з кожною стороною вирівняного осі. Зробіть це, знайшовши рівняння нескінченної прямої, на якій лежить кожна сторона (тобто v1 + t (v2-v1) і v'1 + t '(v'2-v'1) в основному), знаходячи точку, в якій рядки відповідають, вирішуючи для t, коли ці два рівняння рівні (якщо вони паралельні, ви можете перевірити це), а потім перевірити, чи лежить ця точка на відрізку лінії між двома вершинами, тобто чи правда, що 0 <= t <= 1 і 0 <= t '<= 1.

Однак це не стосується випадку, коли один прямокутник повністю покриває інший. Це ви можете покрити, перевіривши, чи лежать усі чотири точки прямокутника всередині іншого прямокутника.

Ось що я зробив би для 3D- версії цієї проблеми:

Моделюйте 2 прямокутники як площини, описані рівнянням P1 і P2, потім запишіть P1 = P2 і виводите з цього рівняння рівняння перетину, якого не буде, якщо площини паралельні (немає перетину) або знаходяться в одній площині, в такому випадку ви отримуєте 0 = 0. У такому випадку вам потрібно буде використовувати алгоритм перетину 2D прямокутника.

Тоді я побачив би, чи проходить ця лінія, яка знаходиться в площині обох прямокутників, через обидва прямокутники. Якщо це так, то у вас перетин двох прямокутників, інакше ви цього не робите (або не слід, я, можливо, пропустив кутовий корпус в голові).

Щоб дізнатись, чи проходить лінія через прямокутник в одній площині, я знайшов би 2 точки перетину прямої та сторони прямокутника (моделюючи їх за допомогою рівнянь ліній), а потім переконайтесь, що точки перетину знаходяться у дальність.

Це математичні описи, на жаль, я не маю коду робити вище.

Інший спосіб зробити тест, який є трохи швидшим, ніж використання тесту з роздільною віссю, - це використовувати алгоритм обмотки чисел (лише для квадрантів - не підсумовування кутів, яке жахливо повільно) на кожній вершині будь-якого прямокутника (вибрано довільно). Якщо будь-яка з вершин має ненульове число обмотки, два прямокутники перекриваються.

Цей алгоритм є дещо більш звивистим, ніж тест з роздільною віссю, але більш швидкий, оскільки він вимагає лише тесту на півплощини, якщо краї перетинають два квадранти (на відміну від до 32 тестів методом роздільної осі)

Алгоритм має ще одну перевагу в тому, що його можна використовувати для перевірки перекриття будь-якого багатокутника (опуклого або увігнутого). Наскільки мені відомо, алгоритм працює лише у 2D просторі.

Чи я пропускаю щось інше, чому це зробити так складно?

якщо (x1, y1) і (X1, Y1) кути прямокутників, то для знаходження перетину зробіть:

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

Я реалізував це так:

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

Матриця mB - це будь-яка афінна матриця перетворення, яка перетворює точки в B просторі в точки в просторі A. Сюди входить просте обертання та переклад, обертання плюс масштабування та повні афінні основи, але не перспективні основи.

Це може бути не максимально оптимальним. Швидкість не викликала великого занепокоєння. Однак, здається, це працює добре для мене.

Ось реалізація прийнятої відповіді за програмою matlab:

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

Це звичайний метод, перейдіть по черзі і перевірте, чи перетинаються лінії. Це код у 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

функцію InterX можна завантажити з: https://in.mathworks.com/matlabcentral/fileexchange/22441-curve-intersections?focused=5165138&tab=function

У мене є більш спрощений метод, якщо у нас є 2 прямокутника:

R1 = (min_x1, max_x1, min_y1, max_y1)

R2 = (min_x2, max_x2, min_y2, max_y2)

Вони перетинаються, якщо і тільки якщо:

Перекриття = (max_x1> min_x2) і (max_x2> min_x1) і (max_y1> min_y2) і (max_y2> min_y1)

Ви можете зробити це і для 3D-коробок, адже це працює для будь-якої кількості вимірів.

Досить сказано в інших відповідях, тому я просто додам псевдокод-один вкладиш:

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