我试图写一个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 >=.