求两个矩形是否相交

最新推荐文章于 2021-04-28 11:08:02 发布
最新推荐文章于 2021-04-28 11:08:02 发布
阅读量198 收藏
点赞数
分类专栏： C# 文章标签： 区域相交 C#算法 有角度的直线产生的区域
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Evelyn_LiuZhen/article/details/98852255
版权 
GetRegion(double x1, double y1, double x2, double y2, double dir, double allowShift = 3 * Math.PI / 180)
 {
            dir = RouteMathExtend.TurnToFixedRegion(dir, 0, 2 * Math.PI);
            List<PointD> regionPoints = new List<PointD>();

            double xl, xr, yu, yd;

            xl = xLeft ;
            xr = xright ;
            yu = yUpper ;
            yd = yDown ;
           
            double minX = Math.Min(x1, x2);
            double maxX = Math.Max(x1, x2);
            double minY = Math.Min(y1, y2);
            double maxY = Math.Max(y1, y2);

            double width = xl + xr;
            double height = yu + yd;

            if (Math.Abs(dir) < allowShift || Math.Abs(dir - Math.PI * 2) < allowShift)
            {
                RectangleF rec = new RectangleF((float)(minX - yd), (float)(minY - xr), (float)(maxX - minX + height), (float)(maxY - minY + width));
                regionPoints.Add(new PointD(rec.Left, rec.Top));
                regionPoints.Add(new PointD(rec.Right, rec.Top));
                regionPoints.Add(new PointD(rec.Right, rec.Bottom));
                regionPoints.Add(new PointD(rec.Left, rec.Bottom));
            }
            else if (Math.Abs(dir - Math.PI / 2) < allowShift)
            {
                RectangleF rec = new RectangleF((float)(minX - xl), (float)(minY - yd), (float)(maxX - minX + width), (float)(maxY - minY + height));
                regionPoints.Add(new PointD(rec.Left, rec.Top));
                regionPoints.Add(new PointD(rec.Right, rec.Top));
                regionPoints.Add(new PointD(rec.Right, rec.Bottom));
                regionPoints.Add(new PointD(rec.Left, rec.Bottom));
            }
            else if (Math.Abs(dir - Math.PI) < allowShift)
            {
                RectangleF rec = new RectangleF((float)(minX - yu), (float)(minY - xl), (float)(maxX - minX + height), (float)(maxY - minY + width));
                regionPoints.Add(new PointD(rec.Left, rec.Top));
                regionPoints.Add(new PointD(rec.Right, rec.Top));
                regionPoints.Add(new PointD(rec.Right, rec.Bottom));
                regionPoints.Add(new PointD(rec.Left, rec.Bottom));
            }
            else if (Math.Abs(dir - Math.PI / 2 * 3) < allowShift)
            {
                RectangleF rec = new RectangleF((float)(minX - xr), (float)(minY - yu), (float)(maxX - minX + width), (float)(maxY - minY + height));
                regionPoints.Add(new PointD(rec.Left, rec.Top));
                regionPoints.Add(new PointD(rec.Right, rec.Top));
                regionPoints.Add(new PointD(rec.Right, rec.Bottom));
                regionPoints.Add(new PointD(rec.Left, rec.Bottom));
            }
            else
            {
                double k1 = Math.Tan(dir);
                double k2 = -1 / k1;//与当前线段垂直的斜率
                double cosA = Math.Cos(dir);
                double sinA = Math.Sin(dir);
                double b1, b2, b3, b4, c1, c2, c3, c4, p, q;
                b1 = b3 = y1 - x1 * k1;
                b2 = y1 < y2 ? y1 - x1 * k2 : y2 - x2 * k2;
                b4 = y1 > y2 ? y1 - x1 * k2 : y2 - x2 * k2;
                if (cosA > 0) p = 1; else p = -1;
                if (sinA > 0) q = 1; else q = -1;
                c1 = b1 + p * xl * Math.Pow((1 + k1 * k1), 0.5);
                c3 = b3 - p * xr * Math.Pow((1 + k1 * k1), 0.5);
                if (q > 0)
                {
                    c2 = b2 - yd * Math.Pow((1 + k2 * k2), 0.5);
                    c4 = b4 + yu * Math.Pow((1 + k2 * k2), 0.5);
                }
                else
                {
                    c2 = b2 - yd * Math.Pow((1 + k2 * k2), 0.5);
                    c4 = b4 + yu * Math.Pow((1 + k2 * k2), 0.5);
                }

                double x, y;
                if (CalCrossPoint(k1, k2, c1, c2, out x, out y))
                    regionPoints.Add(new PointD(Math.Ceiling(x), Math.Ceiling(y)));
                else
                    Debug.WriteLine("求取路径顶点时有误");
                if (CalCrossPoint(k1, k2, c3, c2, out x, out y))
                    regionPoints.Add(new PointD(Math.Floor(x), Math.Ceiling(y)));
                else
                    Debug.WriteLine("求取路径顶点时有误");
                if (CalCrossPoint(k1, k2, c3, c4, out x, out y))
                    regionPoints.Add(new PointD(Math.Floor(x), Math.Floor(y)));
                else
                    Debug.WriteLine("求取路径顶点时有误");
                if (CalCrossPoint(k1, k2, c1, c4, out x, out y))
                    regionPoints.Add(new PointD(Math.Ceiling(x), Math.Floor(y)));
                else
                    Debug.WriteLine("求取路径顶点时有误");

            }

            if (regionPoints.Count > 0)
                regionPoints.Add(regionPoints[0]);
            return new CommonRegion(0, regionPoints, null, null, 0, null);
        }


bool CalCrossPoint(double k1, double k2, double b1, double b2, out double x, out double y)
        {
            x = 0;
            y = 0;
            if (k1!=k2)
            {
                x = (b2 - b1) / (k1 - k2);
                y = (b2 * k1 - b1 * k2) / (k1 - k2);
                return true;
            }
            return false;
        }


    /// <summary>
        /// 计算两个区域是否相交，
        /// 需要考虑的情形有：
        ///  1、一个区域包含在另一个区域内，此时可用点在区域内的算法计算
        ///  2、一个区域与另一个区域由部分重叠，且重叠区域不包括边界点
        /// </summary>
        /// <param name="region"></param>
        /// <returns></returns>
        public bool IsIntersect(List<PointD>BoundaryPoints)
        {
            
            for (int i = 0; i < this.BoundaryPoints.Count - 1; i++)
            {
                PointD p = this.BoundaryPoints[i];
                if (IsInTheRegion(p.X, p.Y))
                    return true;
            }
            for (int i = 0; i < BoundaryPoints.Count - 1; i++)
            {
                PointD p = region.BoundaryPoints[i];
                if (this.IsInTheRegion(p.X, p.Y))
                    return true;
            }

            for (int i = 1; i < BoundaryPoints.Count; i++)
            {
                for (int j = 1; j < this.BoundaryPoints.Count; j++)
                {
                    if (CheckLineCross(BoundaryPoints[i].X, region.BoundaryPoints[i].Y, BoundaryPoints[i - 1].X, BoundaryPoints[i - 1].Y,
                         this.BoundaryPoints[j].X, this.BoundaryPoints[j].Y, this.BoundaryPoints[j - 1].X, this.BoundaryPoints[j - 1].Y))
                        return true;
                }
            }

            return false;
        }


 bool IsInTheRegion(List<PointD> BoundaryPoints, double x, double y)
        {
            var pts = new List<PointD>(BoundaryPoints);
            double offset = 20;
            if (pts.Count == 0) return false;
            else if (pts.Count == 1)
            {
                return NearPoint(pts[0], (new PointD(x, y)), offset);
            }
            else if (pts.Count == 2)
            {
                if (pts[0].Equals(pts[1]))
                {
                    return NearPoint(pts[0], (new PointD(x, y)), offset);
                }
                else
                {
                    return DisPointToLineSegment(x, y, pts[0].X, pts[0].Y, pts[1].X, pts[1].Y) < offset;
                }
            }
            else if (pts.Count == 3)
            {
                if (NearPoint(pts[0], pts[2], offset))
                {
                    if (NearPoint(pts[0], pts[1], offset))
                    {
                        return NearPoint(pts[0], (new PointD(x, y)), offset);
                    }
                    else
                    {
                        return DisPointToLineSegment(x, y, pts[0].X, pts[0].Y, pts[1].X, pts[1].Y) < offset;
                    }
                }
            }
            if (!NearPoint(pts[0], pts.Last(), offset)) pts.Add(pts[0]);

            if (pts == null || pts.Count == 0)
                return false;
            double minx = pts[0].X;
            double maxx = pts[0].X;
            double miny = pts[0].Y;
            double maxy = pts[0].Y;
            for (int i = 1; i < pts.Count - 1; i++)
            {
                if (pts[i].X < minx)
                    minx = pts[i].X;
                if (pts[i].X > maxx)
                    maxx = pts[i].X;
                if (pts[i].Y < miny)
                    miny = pts[i].Y;
                if (pts[i].Y > maxy)
                    maxy = pts[i].Y;
            }

            Rectangle MaxRectangle = new Rectangle((int)minx, (int)miny, (int)(maxx - minx), (int)(maxy - miny));

            if (x < MaxRectangle.Left || x > MaxRectangle.Right || y < MaxRectangle.Top || y > MaxRectangle.Bottom)
                return false;

            int[] index = new int[4];
            for (int i = 0; i < pts.Count - 1; i++)
            {
                if (Math.Abs(pts[i].X - x) < 20 && Math.Abs(pts[i].Y - y) < 20)
                    return true;

                if (CheckPointAboveLine(x, y, pts[i].X, pts[i].Y, pts[i + 1].X, pts[i + 1].Y) == 0 &&
                    OnLineSegment(x, y, pts[i].X, pts[i].Y, pts[i + 1].X, pts[i + 1].Y))
                    return true;

                if (CheckLineCross(x, y, x + MaxRectangle.Width, y, pts[i].X, pts[i].Y, pts[i + 1].X, pts[i + 1].Y))
                {
                    index[0]++;
                }
                if (RouteMath.CheckLineCross(x, y, x - MaxRectangle.Width, y, pts[i].X, pts[i].Y, pts[i + 1].X, pts[i + 1].Y))
                {
                    index[1]++;
                }
                if (CheckLineCross(x, y, x, y + MaxRectangle.Height, pts[i].X, pts[i].Y, pts[i + 1].X, pts[i + 1].Y))
                {
                    index[2]++;
                }
                if (CheckLineCross(x, y, x, y - MaxRectangle.Height, pts[i].X, pts[i].Y, pts[i + 1].X, pts[i + 1].Y))
                {
                    index[3]++;
                }

            }

            foreach (int i in index)
            {
                if (i % 2 != 1)
                    return false;

            }
            return true;
        }

这里计算相交用的是最笨的计算方法，所以计算时间较长，需要考虑优化问题。

 

快乐小丸子~
关注
专栏目录
计算两个矩形是否相交以及相交的矩形
jiangboyao1993的博客
11-21 1745
最近在开发的时候遇到一个问题，就是要判断在同一个直角坐标系下，两个边与坐标轴平行的矩形是否相交。 （应用到三维坐标系上也是同样的道理，就是先降维，再把条件&&起来，这里就不再赘述了） 在网上看到了很多解决方案，都是分情况讨论，虽然复杂度并不高，但是觉得代码量有点冗余。最后想到了如下算法能够判断出结果。 既然难以判断讨论相交关系，就直接判断不相交 显而易见的是，如果一个矩形在
java判断两个矩形是否相交_Java-JAVA面试题，判断两个矩形是否相交的方法
weixin_39717367的博客
02-13 1917
简单的思路，如果两个四边形相交，则必然有两条边相交，所以只需要判断任意两条边不相交，则两个四边形不相交，以下是代码。但是有一个问题，没有判断一个四边形在另一个四边形里面的情况！package com.phoenix;public class JudgeRectCross {/*** @param args*/public static void main(String[] args) {// 定义...
flash判断旋转矩形是否相交
11-29
判断任意位置旋转的矩形是否相交，相交输出true，否则输出false。
如何判断两个矩形是否相交
szv123_rier的专栏
10-22 4869
http://toumao.blog.sohu.com/13648650.html 　　有朋友在论坛上提问，如何判断两个矩形是否相交，他自己的初步想法是这样的： 　　1、一个矩形只有一个角的点在另一个矩形内； 　　2、一个矩形a只一条边上的2个顶角在另一个矩形b内（这种情况对于另一个矩形b来说却是4个顶角都在矩形a之外，所以要交换判断）。 　　3、一个矩形穿过另一个矩形； 　　这位朋友想
求取两个矩形的相交区域
007的博客
07-29 4647
        在此讨论的求取两个矩形的相交区域问题中的矩形的边是平行于坐标轴的情况，不平行的暂时无讨论。        因为工作的需要求取两个矩形的相交区域面积的python程序，当时在网上找呀找，要么是说的云里雾里的，要么代码不是python的，其实主要是矩形相交判断条件，有的说的那叫一个复杂呀，还好在查找过程中找到了两篇不错的博客 blog1:https://blog.csdn.net/...
判断两个矩形相交以及求出相交的区域(生成的相交矩形)
mmdev
01-31 949
原文来自：http://051031wangcj.blog.163.com/blog/static/334067622010112841335693/ 问题：给定两个矩形A和B，矩形A的左上角坐标为（Xa1,Ya1），右下角坐标为（Xa2,Ya2），矩形B的左上角坐标为（Xb1,Yb1），右下角 坐标为（Xb2,Yb2）。 （1）设计一个算法，确定两个矩形是否相交（即有重叠区域） （2）如果...
python判断两个矩形是否相交_使用Python判断线段是否与矩形相交
weixin_39869959的博客
12-04 1597
直线相交的判定我们在初等几何中学过如何判断两条直线是否相交。在欧几里得平面上，两条直线要么平行，要么相交，要么重合。这是欧几里得第五公设的推论。相交的两条直线恰好有一个交点，而重合的两条直线有无数个交点。判断两条直线位置关系的代数方法是：联立两条之直线方程，无解，则两条直线平行，存在唯一解则两条直线相交，存在两个及以上的解，则两直线重合。联立直线方程线段相交的判定：分为矩形判定和叉积判定两步ste...
Python判断直线和矩形是否相交的方法
09-21
该函数接受8个参数，分别是直线上的两个点A和B的x、y坐标，以及矩形的左上角和右下角的x、y坐标。函数首先将所有输入转换为浮点数，以进行精确的浮点数运算，避免整数除法带来的误差。 接下来，函数通过计算直线AB...
C++判断矩形相交的方法
09-03
如果两个矩形相交，那么它们的交集将形成一个新的矩形。这个新矩形的左上角坐标是两个矩形左上角坐标的较大者，即min(minx1, minx2)和min(miny1, miny2)。这个新矩形的右下角坐标是两个矩形右下角坐标的较小者，即...
判断两个矩形是否相交
hello____world_0109的博客
03-08 2586
判断两个矩形是否相交 一个矩形由两个端点确定，即左上角和右下角。 两个矩形相交时有公共部分<=>两矩形相交时，长或宽经过平移都后有重叠的部分<=>两矩形相交时，其外包矩形的长或宽都小于两矩形的长或宽之和 <=>两矩形相交时，其外包矩形的中心点被两矩形包含 两个矩形（x11,y11,x12,y12）和（x21,y21,x22,y22）,max(|x11-x22|,|x21-x12|)即为外包矩形宽，max(|y11-y22|,|y12-y21|)即为外包矩形高。分别与两矩形
判断两个矩形是否相交的4个方法
weixin_30256901的博客
02-21 3216
http://blog.csdn.net/cxf7394373/article/details/7535105 最近在用opencv寫一個文本定位的程序，獲取到字符輪廓之後需要進行合並，涉及到判斷矩形是否相交的問題，記得去年去三星通信研究院面試同樣問到了這個問題，如何判斷兩條線段是否相交，如何判斷兩個矩形是否相交。以前寫過一篇如何判斷線段相交的問題，上網查了一些方法，在這裡做一下後一...
关于判断两个矩形是否相交
tjlog的专栏
03-15 1626
给定一个矩阵A的长宽及左上角的坐标(x,y)，矩阵B的长宽及左上角的坐标(x1,y1)，则只需要两者坐标相交处是否依旧能构成一个矩阵即可以啦，代码如下： let Rect = function (x, y, height, width) { this.x = x; this.y = y; this.height = height; this.width = w...
判断两个矩形是否相交算法
u013067420的博客
08-10 8601
两个矩形的空间位置（2d）有四种情况，如下图: 给两个矩形命名为A，B分别却两个矩形的坐上和右下角坐标(Ax0,Ay0),(Bx0,By0),根据四种情况的判断相交有四种情况，也就是说要写四个判断，这个就有点啰嗦了，其实根据这四种情况可以推出规律，如下图: 这样算法就可以写为 Bx1>Ax0,By1>Ay1,Ax1>Bx0,Ay1>By0 下面是一个用js写的例子，当然是别
算法：判断同一平面，两个任意旋转角度的矩形是否相交
weixin_38027841的博客
04-28 2207
步骤： 先把两个矩形分为4个三角形 然后确认是否为回字型 （线段是否相交进行判断，两点是否在另一线段同/异侧） 如果不是回字形则判断一个矩形的4个顶点是否在另外一个矩形所分的两个三角形内部 判断点在三角形内部：https://blog.csdn.net/pdcxs007/article/details/51436483 ...
判断两矩形是否交叉（包括包含的情况）
itjobtxq的专栏
05-20 1482
问题：给定两个矩形A和B，矩形A的左上角坐标为（Xa1,Ya1），右下角坐标为（Xa2,Ya2），矩形B的左上角坐标为（Xb1,Yb1），右下角坐标为（Xb2,Yb2）。（1）设计一个算法，确定两个矩形是否相交（即有重叠区域）（2）如果两个矩形相交，设计一个算法，求出相交的区域矩形(1)对于这个问题，一般的思路就是判断一个矩形的四个顶点是否在另一个矩形的区域内。这个思路最简单，但是效率不高，并且存在错误，错误在哪里，下面分析一下。如上图，把矩形的相交（区域重叠）分成三种（可能也有其他划分），对于第三种情况，
判断两矩形是否相交，相交的话 求出相交的面积和相交处比例
xiao_lxl的专栏
05-30 3871
opencv_判断两矩形是否相交，相交的话 求出相交的面积和相交处比例 float bbOverlap(const BoundingBox& box1,const BoundingBox& box2) { if (box1.x > box2.x+box2.width) { return 0.0; } if (box1.y > box2.y+box2.height) { return 0.0;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值