//=================================================================
#include <afxwin.h>
#include <iostream.h>
int area(RECT a, RECT b)
{
RECT temp;
if (a.left>b.left)
{
temp = a;
a = b;
b = temp;
}
POINT pt[8];
pt[0].x = a.left;
pt[0].y = a.top;
pt[1].x = a.right;
pt[1].y = a.top;
pt[2].x = a.left;
pt[2].y = a.bottom;
pt[3].x = a.right;
pt[3].y = a.bottom;
pt[4].x = b.left;
pt[4].y = b.top;
pt[5].x = b.right;
pt[5].y = b.top;
pt[6].x = b.left;
pt[6].y = b.bottom;
pt[7].x = b.right;
pt[7].y = b.bottom;
POINT pt_in1[4] = {0};
int count1 = 0;
POINT pt_in2[4] = {0};
int count2 = 0;
BOOL ret1 = FALSE;
int i=0;
for (;i<4;i++)
{
ret1 = PtInRect(&b , pt[i]);
if (ret1==TRUE)
{
cout<<"点在矩形内"<<endl;
pt_in1[count1] = pt[i];
count1++;
cout<<'(' << pt[i].x <<',' << pt[i].y <<")"<<endl;
}
}
BOOL ret2 = FALSE;
for (i=4;i<8;i++)
{
ret2 = PtInRect(&a , pt[i]);
if (ret2==TRUE)
{
cout<<"点在矩形内"<<endl;
pt_in2[count2] = pt[i];
count2++;
cout<<'(' << pt[i].x <<',' << pt[i].y <<")"<<endl;
}
}
if (count1==1 && count2==1)
{
return (pt_in1[count1-1].x - pt_in2[count2-1].x) * (pt_in1[count1-1].y - pt_in2[count2-1].y);
}
else if (count1==2 && count2==0 && pt_in1[0].x==pt_in1[1].x)
{
return (a.right-b.left ) * (a.bottom-a.top);
}
else if (count1==0 && count2==2 && pt_in2[0].x==pt_in2[1].x)
{
return (a.right-b.left ) * (b.bottom-b.top);
}
else if (count1==0 && count2==2 &&pt_in1[0].y==pt_in1[1].y)
{
if (b.bottom<a.bottom && b.bottom>a.top)
{
return (b.bottom-a.top) * (b.right-b.left);
}
else
return (a.bottom-b.top) * (b.right-b.left);
}
else if (count1==0 && count2==4)
{
return (b.right-b.left ) * (b.bottom-b.top);
}
if (b.right<a.right && b.top>a.top && b.bottom>a.bottom)
{
return (b.right-b.left) * (a.bottom-a.top);
}
return -1;
}
void main()
{
int ax1 = 0 ; int bx1 = 80;
int ax2 = 100; int bx2 = 200;
int ay1 = 0; int by1 = 45;
int ay2 = 50; int by2 = 80;
RECT rect_a;
rect_a.left = ax1;
rect_a.top = ay1;
rect_a.right = ax2;
rect_a.bottom = ay2;
RECT rect_b;
rect_b.left = bx1;
rect_b.top = by1;
rect_b.right = bx2;
rect_b.bottom = by2;
cout<< area(rect_a,rect_b) <<endl;;
}
struct rect
{
// axis alignment assumed
// bottom left is (x[0],y[0]), top right is (x[1],y[1])
double x [2];
double y [2];
};
template <typename T> T const& min (T const& x, T const& y) { return x<y ? x : y; }
template <typename T> T const& max (T const& x, T const& y) { return x>y ? x : y; }
// return type changed to handle non-integer rects
double area (rect const& a, rect const& b)
{
// perfectly adjacent rects are considered having an intersection of 0 area
double const dx = min(a.x[1],b.x[1]) - max(a.x[0],b.x[0]);
double const dy = min(a.y[1],b.y[1]) - max(a.y[0],b.y[0]);
return dx>=0&&dy>=0 ? dx*dy : -1;
}
class vectorf
{
public:
vectorf(float x, float y, float z) {
ele[0] = x;
ele[1] = y;
ele[2] = z;
}
float& x() { return ele[0]; }
float& y() { return ele[1]; }
float& z() { return ele[2]; }
protected:
float ele[3];
};
inline min(float a, float b) { return a<b?a:b; }
inline max(float a, float b) { return a>b?a:b; }
class AABB
{
AABB(const vectorf& center, const vectorf& radius)
: o(center)
, r(radius)
{}
// 如果相交，返回体积
// 如果不相交，返回0
inline float intersects（const AABB& other) {
// 任意一轴分离，即不相交
// 每轴只有两种情况：A<=B 或者B<=A
if ( ( o.x()+r.x() <= other.o.x()-other.r.x() )
|| ( other.o.x()+other.r.x() <= o.x()-r.x() )
|| ( o.y()+r.y() <= other.o.y()-other.r.y() )
|| ( other.o.y()+other.r.y() <= o.y()-r.y() )
|| ( o.z()+r.z() <= other.o.z()-other.r.z() )
|| ( other.o.z()+other.r.z() <= o.z()-r.z() )
)
{
return 0;
}
// 求相交体积
// 在每轴上，相交体的低值是两AABB低值的较高者，高值是两AABB高值的较低者
else {
float x_low = max( o.x()-r.x(), other.o.x()-other.r.x() );
float x_high = min( o.x()+r.x(), other.o.x()+other.r.x() );
float y_low = max( o.y()-r.y(), other.o.y()-other.r.y() );
float y_high = min( o.y()+r.y(), other.o.y()+other.r.y() );
float z_low = max( o.z()-r.z(), other.o.z()-other.r.z() );
float z_high = min( o.z()+r.z(), other.o.z()+other.r.z() );
return (x_high-x_low) * (y_high-y_low) * (z_high-z_low);
}
}
protected:
vectorf o;
vectorf r;
};
typedef struct tagRect
{
int left;
int top;
int right;
int bottom;
} Rect;
#define MIN(a,b) ( (a)>(b)?(b):(a) )
#define MAX(a,b) ( (a)>(b)?(a):(b) )
int CalcArea(Rect const& a, Rect const& b)
{
int minRight = MIN(a.right, b.right);
int maxLeft = MAX(a.left, b.left);
int minBottom = MIN(a.bottom, b.bottom);
int maxTop = MAX(a.top, b.top);
if(minRight>maxLeft && minBottom>maxTop)
{
return ( (minRight-maxLeft) * (minBottom-maxTop));
}
else
{
return -1;
}
}
//在一个平面坐标系上，有两个矩形，它们的边分别平行于X和Y轴。
//其中，矩形A已知， ax1(左边), ax2（右边）, ay1（top的纵坐标）, ay2（bottom纵坐标）. 矩形B，类似，就是 bx1, bx2, by1, by2。这些值都是整数就OK了。
//要求是，如果矩形没有交集，返回-1， 有交集，返回交集的面积。
int area() {
int b1c=0,b2c=0;
if (bx1<ax1) b1c+=10;
else if (ax2<=bx1) b1c+=30;
else b1c+=20;
if (by1<ay1) b1c+= 1;
else if (ay2<=by1) b1c+= 3;
else b1c+= 2;
if (bx2<ax1) b2c+=10;
else if (ax2<=bx2) b2c+=30;
else b2c+=20;
if (by2<ay1) b2c+= 1;
else if (ay2<=by2) b2c+= 3;
else b2c+= 2;
switch (b1c*100+b2c) {
case 1111:
case 1112:
case 1113:
case 1121:
case 1131:
case 1212:
case 1213:
case 1313:
case 1323:
case 1333:
case 2121:
case 2131:
case 2323:
case 2333:
case 3131:
case 3132:
case 3133:
case 3232:
case 3233:
case 3333:
return -1;
case 1122:
return (bx2-ax1)*(by2-ay1);
case 1123:
return (bx2-ax1)*(ay2-ay1);
case 1132:
return (ax2-ax1)*(by2-ay1);
case 1133:
return (ax2-ax1)*(ay2-ay1);
case 1222:
return (bx2-ax1)*(by2-by1);
case 1223:
return (bx2-ax1)*(ay2-by1);
case 1232:
return (ax2-ax1)*(by2-by1);
case 1233:
return (ax2-ax1)*(ay2-by1);
case 2122:
return (bx2-bx1)*(by2-ay1);
case 2123:
return (bx2-bx1)*(ay2-ay1);
case 2132:
return (ax2-bx1)*(by2-ay1);
case 2133:
return (ax2-bx1)*(ay2-ay1);
case 2222:
return (bx2-bx1)*(by2-by1);
case 2223:
return (bx2-bx1)*(ay2-by1);
case 2232:
return (ax2-bx1)*(by2-by1);
case 2233:
return (ax2-bx1)*(ay2-by1);
case 1211:
case 1221:
case 1231:
case 1311:
case 1312:
case 1321:
case 1322:
case 1331:
case 1332:
case 2111:
case 2112:
case 2113:
case 2211:
case 2212:
case 2213:
case 2221:
case 2231:
case 2311:
case 2312:
case 2313:
case 2321:
case 2322:
case 2331:
case 2332:
case 3111:
case 3112:
case 3113:
case 3121:
case 3122:
case 3123:
case 3211:
case 3212:
case 3213:
case 3221:
case 3222:
case 3223:
case 3231:
case 3311:
case 3312:
case 3313:
case 3321:
case 3322:
case 3323:
case 3331:
case 3332:
printf("not ax1<=ax2 or not ay1<ay2 or not bx1<bx2 or not by1<by2!");
return -1;
break;
}
}
template<typename T>
inline typename std::conditional<std::is_arithmetic<T>::value, T, T const>::type
median(typename std::conditional<std::is_arithmetic<T>::value, T, T const&>::type a,
typename std::conditional<std::is_arithmetic<T>::value, T, T const&>::type b,
typename std::conditional<std::is_arithmetic<T>::value, T, T const&>::type c)；
