甘草大佬今天连出几道题目...顶先，吃饭去鸟。

第一个矩形的左上坐标为(ax1, ay1)，右下坐标为(ax2, ay2)

第二个矩形的左上坐标为(bx1, by1)，右下坐标为(bx2, by2)

满足相交的条件是：第一个矩形的左上坐标点 和 第二个矩形的右下坐标点 之间的横、纵轴的差的绝对值，小于两个矩形的横、纵边长之和。 所以又：

| bx2 - ax1 | ≤ (ax2 - ax1) + (bx2 - bx1) and
| ay1 - by2 | ≤ (ay1 - ay2) + (by2 - by1)

引用 2 楼  的回复:

第一个矩形的左上坐标为(ax1, ay1)，右下坐标为(ax2, ay2)

第二个矩形的左上坐标为(bx1, by1)，右下坐标为(bx2, by2)

满足相交的条件是：第一个矩形的左上坐标点 和 第二个矩形的右下坐标点 之间的横、纵轴的差的绝对值，小于两个矩形的横、纵边长之和。 所以又：

| bx2 - ax1 | ≤ (ax2 - ax1) + (bx2 - bx1) an……

这个判据貌似不正确。

引用 3 楼  的回复:

这个判据貌似不正确。

您觉得哪里有问题呢？

代码代码代码~~~~~~

引用 4 楼  的回复:

引用 3 楼  的回复:
这个判据貌似不正确。

您觉得哪里有问题呢？

你是不是认为A一定在B的左边呢？ 

引用 6 楼  的回复:

引用 4 楼  的回复:

引用 3 楼  的回复:
这个判据貌似不正确。

您觉得哪里有问题呢？

你是不是认为A一定在B的左边呢？

A在B的右边的情况是对称的

我是懒得写代码的，你知道的~~

{
if(ax1>=bx2 || ax2<=bx1)
    return 0 ;
if(ay1>=by2 || ay2<=by1)
    return 0 ;
return 1 ;
}

引用 7 楼  的回复:

引用 6 楼  的回复:

引用 4 楼  的回复:

引用 3 楼  的回复:
这个判据貌似不正确。

您觉得哪里有问题呢？

你是不是认为A一定在B的左边呢？

A在B的右边的情况是对称的

我是懒得写代码的，你知道的~~

NO,... ...必须的...理论是理论，正确的理论写出来的代码可能很长很长。

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

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





} 

写了就是好样的，不过有点长...

引用 11 楼  的回复:

写了就是好样的，不过有点长...

确实，还可以简化很多

引用 12 楼  的回复:

引用 11 楼  的回复:
写了就是好样的，不过有点长...

确实，还可以简化很多

那继续吧，貌似我的代码可能在10-20行之间。

how about this one?

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;

}

引用 14 楼  的回复:

how about this one?

C/C++ code

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……

验证过么？

引用 13 楼  的回复:

引用 12 楼  的回复:

引用 11 楼  的回复:
写了就是好样的，不过有点长...

确实，还可以简化很多

那继续吧，貌似我的代码可能在10-20行之间。

代码长度很重要么？
效率也很重要
写一个遍历所有像素点的好（没几行），还是几十行，效率高的？

引用 15 楼  的回复:

引用 14 楼  的回复:
how about this one?

C/C++ code

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 <t……
验证过么？

试了几个例子都行。理论上讲，对于有交集的矩形，取极大极小和极小极大就应该是交集的限定；对于没有交集的，则构造出的矩形必然有一个维度是逆向的，强行按正向的算，则边长自然为负值，此事实恰好可以用于判断交集的存在性。如果你发现反例，也请分享一下。

又想了一下，下面是一个简短的证明。

对于平行于坐标轴的矩形 r，假设其左下角点坐标为 (rx0,ry0)，右上角点坐标为 (rx1,ry1)，那么由 r 定义的无限有界点集为：{(x,y)|x in [rx0,rx1] && y in [ry0,ry1]}。

根据交集的定义，则任意二维点 (x,y) 在矩形 a,b 的交集内等价于
{(x,y)|(x,y) in a 并且 (x,y) in b} <==>
{(x,y)|x in [ax0,ax1] && x in [bx0,bx1] 并且 y in [ay0,ay1] && y in [by0,by1]} <==>
{(x,y)|x in [max(ax0,bx0),min(ax1,bx1)] 并且 y in [max(ay0,ay0),min(ay1,by1)]}
因此，交集矩形的边长分别为 min(ax1,bx1)-max(ax0,bx0) 和 min(ay1,by1)-max(ay0,ay0)。注意当交集为空时(a,b 不相交)，则经此法计算出来的交集边长为负值，此事实可用于验证 a,b 的相交性。

鉴于笛卡尔积各个维度上的不相关性，此方法可扩展到任意有限维线形空间，比如，三维空间中平行于坐标轴的长方体的交集体积可以用类似的方法计算。

有个笔误，
{(x,y)|x in [max(ax0,bx0),min(ax1,bx1)] 并且 y in [max(ay0,ay0),min(ay1,by1)]}
应该是
{(x,y)|x in [max(ax0,bx0),min(ax1,bx1)] 并且 y in [max(ay0,by0),min(ay1,by1)]}

交集的 y 边长为 min(ay1,by1)-max(ay0,by0)。

另外，线形空间->线性空间，
输入法太笨真让人发愁。

引用 16 楼  的回复:

引用 13 楼  的回复:

引用 12 楼  的回复:

引用 11 楼  的回复:
写了就是好样的，不过有点长...

确实，还可以简化很多

那继续吧，貌似我的代码可能在10-20行之间。

代码长度很重要么？
效率也很重要
写一个遍历所有像素点的好（没几行），还是几十行，效率高的？

你看ri_aje的代码，是不是很好懂，效率也不差吧？

看到写 Type const& var的人不多，激动，在Nokia被两个白痴面试，我这么写，他们说我写错了。

引用 18 楼  的回复:

又想了一下，下面是一个简短的证明。

对于平行于坐标轴的矩形 r，假设其左下角点坐标为 (rx0,ry0)，右上角点坐标为 (rx1,ry1)，那么由 r 定义的无限有界点集为：{(x,y)|x in [rx0,rx1] &amp;&amp; y in [ry0,ry1]}。

根据交集的定义，则任意二维点 (x,y) 在矩形 a,b 的交集内等价于
{(x,y)|(x,y) in a……

数学学得好啊！

引用 21 楼  的回复:

看到写 Type const&amp; var的人不多，激动，在Nokia被两个白痴面试，我这么写，他们说我写错了。

水平不高的人，总觉得那么简短的代码不咋可能。。。就像我如果只看ri_aje的代码长度，肯定以为瞎掰的。。
惭愧啊。。

无所谓的，我经常搞UI，MFC的，iOS的，都搞，看到Rect就相对了解一些。

而且它那个短短的代码，有些iOS处理Rect的基因~ GetRectMinX等等。
在iOS上面我肯定会这么处理问题的。


而且X和Y两个维度，其实是同样的问题。好像你没有把他们统一。统一了，一半的代码就不见了。

太简单，我做过按角度旋转，求一个大四边形，包含多少个完整小矩形项目。
以矩形1的任意顶点做为原点。
分两步。
1，求矩形2的四顶点是否落于矩形1中，是则有交集，返回矩形2的那个顶点，继续下一步。否则无交集
2，同理求矩形1落在矩形2的顶点。然后这两点就是交集的对角点。
---------------------
边都是平行于XY轴的，对角点坐标计算面积，横坐标差X纵坐标差即可。

太简单，我做过按角度旋转，求一个大四边形，包含多少个完整小矩形项目。
以矩形1的任意顶点做为原点。
分两步。
1，求矩形2的四顶点是否落于矩形1中，是则有交集，返回矩形2的那个顶点，继续下一步。否则无交集
2，同理求矩形1落在矩形2的顶点。然后这两点就是交集的对角点。
---------------------
边都是平行于XY轴的，对角点坐标计算面积，横坐标差X纵坐标差即可。

引用 14 楼  的回复:

how about this one?
C/C++ code

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&amp……

之前公司自己做的引擎里有提供解决这个问题的接口，我看过源码，基本上和这个是一样的，我自己就懒得写了，赞一个

根本不需要循环和递归之类的操作。
还有情况：
1：落2点在矩形1中，类似同上
2：落4点在矩形1中，交集直接矩形2面积

总之，不用点集合来循环，用简单几何公式来计算交点即可

回复没了，还有落2点和落4点的

这不就是计算机图形学和物理引擎中最常用的AABB相交判定么。
先定义几个类型吧……

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;

};

其实可以做个向量操作来算加减法，而且如果把向量尺寸设为4，容易触发自动SIMD。

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;

	}

}

计算几何大牛:http://www.codeproject.com/KB/recipes/Wykobi.aspx

引用 33 楼  的回复:

计算几何大牛:http://www.codeproject.com/KB/recipes/Wykobi.aspx

赵哥，放心，最后会给你分的 (注意：多回复不会加分)

看懂了,重要看懂了一贴...

没关系，不给分也行。(^_^)

引用 36 楼  的回复:

没关系，不给分也行。(^_^)

肯定给~您老来捧场了都~

这个不给分不行！

//在一个平面坐标系上，有两个矩形，它们的边分别平行于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;

    }

}

赵哥，很难认同你这个叫好的代码。。。 。。。

弱弱的问一句，蒙特卡洛算法怎么样？

请问楼主这不是算法是什么？(^_^)

引用 39 楼  的回复:

赵哥，很难认同你这个叫好的代码。。。 。。。

这不是我的发明。参考《计算机图形学》

KISS － Keep It Simple and Stupid!

是垃圾呗。。。 。。。
要是项目中需要这样的代码，我肯定选择14楼的(简单，清晰，明了，看着让人舒服)，不可能选择你那个（哗众取宠，看着反胃而已）。

不信你发个帖子，问问别人，同样的需求，你的这段代码怎么样？

参考 matlab 的算法



rectint

Rectangle intersection area
area = rectint(A,B) returns the area of intersection of the rectangles specified by position vectors A and B


一堆解释..


edit rectint.m

一堆多维矩阵的处理


最后，第49行的代码，是关键
  out = (max(0, min(rightA, rightB) - max(leftA, leftB))) .* ...
    (max(0, min(topA, topB) - max(bottomA, bottomB)));

%   Copyright 1984-2004 The MathWorks, Inc.
%   $Revision: 1.15.4.1 $  $Date: 2004/03/02 21:48:03 $

这回帖，怎么就消失了


参考 matlab 的算法



rectint

Rectangle intersection area
area = rectint(A,B) returns the area of intersection of the rectangles specified by position vectors A and B


一堆解释..


edit rectint.m

一堆多维矩阵的处理


最后，第49行的代码，是关键
  out = (max(0, min(rightA, rightB) - max(leftA, leftB))) .* ...
    (max(0, min(topA, topB) - max(bottomA, bottomB)));

%   Copyright 1984-2004 The MathWorks, Inc.
%   $Revision: 1.15.4.1 $  $Date: 2004/03/02 21:48:03 $

发现，  14楼的高手的代码， 和 #45， matlab他们的做法，是一样的。

这个算法， 看 matlab的 % Copyright 1984-2004 The MathWorks, Inc.
% $Revision: 1.15.4.1 $ $Date: 2004/03/02 21:48:03 $

1984开始，到2004年之后，再没有新的修订（matlab每半年发布新版本），
 这么多年，这个rect int 久经考验了。

>写一个遍历所有像素点的好（没几行），还是几十行，效率高的？
長不代表效率高，但幾乎肯定比較難維護，解讀
自己去翻翻SGI STL各类演算法的实现，除去那些比较复杂的template语法
你會发现里面的算法都实现的非常簡潔，而且对效率的考量非常的细致

引用 21 楼  的回复:

看到写 Type const&amp; var的人不多，激动，在Nokia被两个白痴面试，我这么写，他们说我写错了。

其实你没错啊，不过pass by reference好象会妨碍编译器把value放到register里面
虽然我有办法可以在编译期解决这个问题，但是那个语法很...不优雅，虽然原理很简单

举例，找三点中值的函数宣告，够丑陋吧？

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

提醒：不能只看代码长短，还要衡量对应的汇编指令数。

引用 49 楼  的回复:

提醒：不能只看代码长短，还要衡量对应的汇编指令数。

提醒个毛，代码是给人看的，这句话没有听过？