//================================================================= 

#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)；