确定两个矩形是否相互重叠?


337

我正在尝试编写一个C ++程序,该程序需要用户输入以下内容以构造矩形(2到5之间):高度,宽度,x-pos,y-pos。所有这些矩形将平行于x和y轴存在,也就是说,它们的所有边缘的斜率均为0或无穷大。

我试图实现在提到的内容问题中但运气并不好。

我当前的实现执行以下操作:

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

但是,我不确定(a)是否已正确实现链接到的算法,或者是否确实做了解释方法?

有什么建议么?


3
我认为您的问题的解决方案不涉及任何乘法。
Scott Evernden

Answers:


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

或者,使用笛卡尔坐标

(如果X1是左坐标,X2是右坐标,则从左到右增加,Y1是下坐标,Y2是下坐标,从下到上增加 -如果这不是您的坐标系的方式(例如,大多数计算机具有Y方向颠倒],在下面交换比较)...

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

假设您有Rect A和RectB。证明是矛盾的。四个条件中的任何一个都保证不会存在重叠

  • 条件1。如果A的左边缘在B的右边缘的右边,则-A完全在B的右边
  • 条件2。如果A的右边缘在B的左边缘的左侧,则-A完全在B的左侧
  • 条件3。如果A的顶部边缘低于B的底部边缘,则-A完全低于B
  • 条件4。如果A的下边缘高于B的上边缘,则-A完全位于B之上

因此,非重叠的条件是

非重叠=> Cond1或Cond2或Cond3或Cond4

因此,重叠的充分条件是相反的。

重叠=>不(Cond1或Cond2或Cond3或Cond4)

德摩根的法律说
Not (A or B or C or D)的与Not A And Not B And Not C And Not D
使用

不是cond1和not cond2和not cond3和not cond4

这等效于:

  • A的左边缘到B的右边缘[ RectA.Left < RectB.Right]和
  • A的右边缘到B的左边缘右侧,[ RectA.Right > RectB.Left],和
  • A的顶部高于B的底部,[ RectA.Top > RectB.Bottom],和
  • A的底部低于B的顶部[ RectA.Bottom < RectB.Top]

注1:很明显,该原理可以扩展到任意数量的尺寸。
注意2:仅计算一个像素的重叠,<并将>该边界上的和/或更改为a <=或a 也应该是很明显的>=
注3:使用笛卡尔坐标(X,Y)时,此答案基于标准代数笛卡尔坐标(x从左到右增加,Y从下到上增加)。显然,在计算机系统可能会以不同的方式机械化屏幕坐标的情况下(例如,从上到下增加Y或从右到左增加X),语法需要相应地进行调整/


488
如果您很难理解它的工作原理,我在silentmatt.com/intersection.html上创建了一个示例页面,您可以在其中拖动矩形并查看比较。
马修·克鲁姆利

4
你不觉得你在使用硬约束吗?如果两个矩形恰好在该边缘彼此重叠怎么办?您不应该考虑<=,> = ??
Nawshad Farruque

6
@MatthewCrumley在您的链接上表示A.Y1 <B.Y2和A.Y2> B.Y1,难道gt&lt符号不能颠倒吗?
NikT

15
为了使它工作,我不得不在最后两个比较中交换<和>
DataGreed

17
不,答案是正确的。它基于标准笛卡尔坐标的使用。如果您使用的是其他系统(Y从上到下递增),请进行适当的调整。
查尔斯·布雷塔纳

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
最简单,最干净的答案。
ldog 2011年

1
@ e.James我想最后一个B.height应该是A.height
mat_boy 2014年

“ min”和“ max”是<windows.h>中的保留关键字。您可以通过#undef min#undef max或使用不同的参数名称来修复它。
mchiasson

如果您使用广泛,则可以将valueInRange换成#define BETWEEN(value,min,max) \ (\ value > max ? max : ( value < min ? min : value )\ )
Ratata Tata,

@Nemo实际上,检查xOverlap是一维的;rectOverlap是二维的。可以使用循环将其扩展到N个尺寸。
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;
}

好一个!应用De Morgans法则可获得:r1.x1 <= r2.x2 && r2.x1 <= r1.x2 && r1.y1 <= r2.y2 && r2.y1 <= r1.y2。
2014年

23

检查矩形是否完全位于另一个矩形之外比较容易,因此检查矩形

在左边...

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

或在右边...

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

或顶部...

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

或在底部...

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

第二个矩形的,它不可能与它碰撞。因此,要有一个返回布尔值的函数,当矩形碰撞时,我们只需通过逻辑“或”组合条件并取反即可:

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

为了仅在触摸时就已经获得肯定的结果,我们可以将“ <”和““>”更改为“ <=”和“> =”。


3
并对其应用德摩根定律。
Borzh 2014年

6

问自己一个相反的问题:如何确定两个矩形是否完全不相交?显然,完全位于矩形B左侧的矩形A不相交。同样,如果A完全在右边。并且类似地,如果A完全在B之上或完全在B之下。在任何其他情况下,A和B相交。

以下内容可能存在错误,但是我对该算法非常有信心:

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

假设您已经定义了矩形的位置和大小,如下所示:

在此处输入图片说明

我的C ++实现是这样的:

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

根据上图给出的示例函数调用:

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

if块内的比较如下所示:

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

这是在Java API中完成的过程:

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

请注意,在C ++中,这些溢出测试将无法进行,因为带符号的整数溢出未定义。
Ben Voigt 2014年

2

在问题中,您链接到数学,以了解矩形何时处于任意旋转角度。但是,如果我对问题中的角度有所了解,我会解释为所有矩形都相互垂直。

通常知道重叠公式的面积是:

使用示例:

   1 2 3 4 5 6

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

1)将所有x坐标(左右两个)收集到一个列表中,然后对其进行排序并删除重复项

1 3 4 5 6

2)将所有y坐标(顶部和底部)收集到一个列表中,然后对其进行排序并删除重复项

1 2 3 4 6

3)通过唯一x坐标之间的间隙数*唯一y坐标之间的间隙数创建2D数组。

4 * 4

4)将所有矩形绘制到此网格中,增加其上出现的每个单元格的计数:

   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)在绘制矩形时,很容易拦截重叠部分。


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

不要认为坐标表示像素在哪里。可以将它们视为位于像素之间。这样,2x2矩形的面积应为4,而不是9。

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

1

最简单的方法是

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

首先,请记住,在计算机中,坐标系是颠倒的。x轴与数学中的轴相同,但是y轴向下增加而向上减小。.如果从中心绘制矩形。如果x1坐标大于x2加上其宽度的一半。那么这意味着他们将互相碰碰一半。并以同样的方式下降+高度的一半。它会碰撞..


1

假设两个矩形分别是矩形A和矩形B。设其中心为A1和B1(可以轻松找出A1和B1的坐标),高度为Ha和Hb,宽度为Wa和Wb,而dx为A1和B1之间的width(x)距离,dy是A1和B1之间的高度(y)距离。

现在我们可以说我们可以说A和B重叠:

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

0

我已经实现了C#版本,它很容易转换为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
对受过训练的人来说,很明显,您的意思是这是Rectangle的扩展类,但是您没有提供任何限制或代码来实际执行此操作。如果您这样做或解释过这就是使用方法的方式,那将是很好的选择,如果您的变量实际上具有足够的描述性名称,那么任何人都可以理解他们的目的/意图,那将是一个加分。
tpartee '19

0

我有一个很简单的解决方案

令x1,y1 x2,y2,l1,b1,l2分别为坐标,长度和宽度

考虑条件((x2

现在,这些矩形重叠的唯一方法是,如果x1,y1的对角线点位于另一个矩形内,或者x2,y2的对角线点位于另一个矩形内。这正是上述条件所暗示的。


0

A和B是两个矩形。C是其覆盖矩形。

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) 

它会照顾所有可能的情况。


0

摘自《 Java编程简介-全面版》一书的练习3.28。该代码测试两个矩形是否为矩形,一个是否在另一个内,以及一个是否在另一个外。如果这些条件都不满足,则两者重叠。

** 3.28(几何:两个矩形),编写一个程序,提示用户输入两个矩形的中心x,y坐标,宽度和高度,并确定第二个矩形是在第一个矩形内还是与第一个矩形重叠,如图3.9所示。测试您的程序以涵盖所有情况。这是示例运行:

输入r1的中心x,y坐标,宽度和高度:2.5 4 2.5 43输入r2的中心x,y坐标,宽度和高度:1.5 5 0.5 3 r2在r1内部

输入r1的中心x,y坐标,宽度和高度:1 2 3 5.5输入r2的中心x,y坐标,宽度和高度:3 4 4.5 5 r2与r1重叠

输入r1的中心x,y坐标,宽度和高度:1 2 3 3输入r2的中心x,y坐标,宽度和高度:40 45 3 2 r2与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

对于那些使用中心点和一半大小作为矩形数据的人,而不是典型的x,y,w,h或x0,y0,x1,x1,您可以按照以下方法进行操作:

#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

如果矩形重叠,则重叠面积将大于零。现在让我们找到重叠区域:

如果它们重叠,则laptop-rect的左边缘将为max(r1.x1, r2.x1),右边缘将为min(r1.x2, r2.x2)。所以重叠的长度将是min(r1.x2, r2.x2) - max(r1.x1, r2.x1)

因此,该区域将是:

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

如果area = 0这样,它们不会重叠。

是不是很简单?


3
这适用于重叠(这是问题),但不适用于相交,因为如果它们恰好在一个角相交,则将不起作用。
兰斯·罗伯兹

我尝试了这段代码,它根本不起作用。即使它们根本不重叠,我也会得到正数。
Brett

@Brett:是的,因为两个负数的乘积为正。
Ben Voigt 2014年

@BenVoigt,问题是当没有重叠时函数没有返回0。我对自己的评论不甚清楚,但是的,我只从该函数收到的区域> 0。
布雷特2014年

如果您正在使用浮点数,那么在进行任何数字比较之前通常使用减法和其他算术运算是一个非常糟糕的主意。特别是如果您需要与一个精确值进行比较-在这种情况下为零。它在理论上有效,但在实践中无效。
玛雅


-1

找出矩形是否相互接触或重叠的Java代码

...

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

...

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.