确定两个矩形彼此重叠？ [英] Determine if two rectangles overlap each other?

问题描述

我试图写一个C ++程序，它从用户以下投入兴建的矩形（2至5之间）：高度，宽度，X POS机，Y-POS。所有这些矩形的将存在平行于x和y轴，即所有它们的边缘将具有0或无穷大斜坡

我试图执行什么是提到在这个的问题，但我没有很多的运气。

我目前的实现执行以下操作：

  //获取所有顶点的矩形1，并将其存储在一个数组 - ＆GT; arrRect1
//点​​1个：arrRect1 [0]，点1 Y：arrRect1 [1]等等...
//获取数组中的所有顶点的矩形2，并将其存储 - ＆GT; arrRect2

//旋转的点边缘，矩形1
INT rot_x，rot_y;
rot_x = -arrRect1 [3];
rot_y = arrRect1 [2];
//在旋转的边缘点
INT pnt_x，pnt_y;
pnt_x = arrRect1 [2];
pnt_y = arrRect1 [3];
//测试点，距离矩形2
INT tst_x，tst_y;
tst_x = arrRect2 [0];
tst_y = arrRect2 [1];

int值;
值=（rot_x *（tst_x  -  pnt_x））+（rot_y *（tst_y  -  pnt_y））;
COUT＆LT;＆LT; 值：＆LT;＆LT;值;
 

不过，我不太清楚，如果（一）我已经实现了我的算法联系到正确的，或者如果我这样做究竟是如何相互preT呢？

有什么建议？

解决方案

 如果（RectA.Left＆LT; RectB.Right和放大器;＆安培; RectA.Right＆GT; RectB.Left＆安培; ＆放大器;
    RectA.Bottom＆LT; RectB.Top＆功放;＆安培; RectA.Top＆GT; RectB.Bottom）
 

或者使用笛卡尔坐标...

 如果（RectA.X1＆LT; RectB.X2和放大器;＆安培; RectA.X2＆GT; RectB.X1和放大器;＆安培;
    RectA.Y1＆LT; RectB.Y2＆功放;＆安培; RectA.Y2＆GT; RectB.Y1）
 

假设你有矩形A和B.矩形 证据是矛盾的。那四个条件保证任何一个没有重叠可以存在

• COND1。如果A的左边缘到B的右边缘的右侧，         - 那么A是完全到右乙
• COND2。如果A的右边缘是到B的左边缘的左侧，         - 那么A是完全向左中乙
• Cond3。如果A的顶部边缘低于B的底部边缘，         - 那么A是完全下文B
• Cond4。如果A的底部边缘高于B的顶部边缘，         - 那么A是完全以上乙

所以条件的非重叠

 COND1或COND2或者Cond3或者Cond4 

因此​​，一个充分条件重叠是相反的（德摩根）

不COND1而不是COND2和不Cond3而不是Cond4 

这是等价于：

• 系统的左边缘到左乙的右边缘，和​​
• A的右边缘到B的左边缘的权利，
• 系统的顶级高于B的底部，和
• 在下文B评出A的底部

注1 ：这是相当明显的同样的原理可以扩展到任何数量的尺寸
注意2 ：这也应该是相当明显的计算只是一个像素的重叠，改＆LT; 和/或＆GT; 上边界为＆LT; = 或＆GT; = 。

I am trying to write a C++ program that takes the following inputs from the user to construct rectangles (between 2 and 5): height, width, x-pos, y-pos. All of these rectangles will exist parallel to the x and the y axis, that is all of their edges will have slopes of 0 or infinity.

I've tried to implement what is mentioned in this question but I am not having very much luck.

My current implementation does the following:

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

However I'm not quite sure if (a) I've implemented the algorithm I linked to correctly, or if I did exactly how to interpret this?

Any suggestions?

解决方案

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

or, using Cartesion coordinates...

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

Say you have Rect A, and Rect B. Proof is by contradiction. Any one of four conditions guarantees that no overlap can exist:

• Cond1. If A's left edge is to the right of the B's right edge, - then A is Totally to right Of B
• Cond2. If A's right edge is to the left of the B's left edge, - then A is Totally to left Of B
• Cond3. If A's top edge is below B's bottom edge, - then A is Totally below B
• Cond4. If A's bottom edge is above B's top edge, - then A is Totally above B

So condition for Non-Overlap is

Cond1 Or Cond2 Or Cond3 Or Cond4

Therefore, a sufficient condition for Overlap is the opposite (De Morgan)

Not Cond1 And Not Cond2 And Not Cond3 And Not Cond4

This is equivalent to:

• A's Left Edge to left of B's right edge, and
• A's right edge to right of B's left edge, and
• A's top above B's bottom, and
• A's bottom below B's Top

Note 1: It is fairly obvious this same principle can be extended to any number of dimensions.
Note 2: It should also be fairly obvious to count overlaps of just one pixel, change the < and/or the > on that boundary to a <= or a >=.

这篇关于确定两个矩形彼此重叠？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！