精华内容
下载资源
问答
  • 严格来说,是要判断产生的点是否共线的,但是这样概率太低,所以我就没有判断。生成的点不能直接连起来,因为点的顺序有可能是错乱的,所以首先要进行顺序判断,方法是计算角度。找到平面内某一点,计算多边形每一个...

    生成多边形

    随机生成若干个点,就可以生成多边形。

    严格来说,是要判断产生的点是否共线的,但是这样概率太低,所以我就没有判断。生成的点不能直接连起来,因为点的顺序有可能是错乱的,所以首先要进行顺序判断,方法是计算角度。找到平面内某一点,计算多边形每一个点到这个点连线和x轴的夹角,对这个夹角进行排序,就可以得到点的顺序,把点依次连起来,就可以得到多边形。这里没有区分凹多边形和凸多边形。

    %% 随机生成两个多边形
    x1=rand(1,4);
    y1=rand(1,4);
    Px=[x1,x1(1)];
    Py=[y1,y1(1)];
    figure(1)
    clf
    ang=cart2pol((x1-mean(x1)),(y1-mean(y1)));
    [sortang,sortindex]=sort(ang);
    sx1=x1(sortindex);
    sy1=y1(sortindex);
    Sx1=[sx1,sx1(1)];
    Sy1=[sy1,sy1(1)];
    plot(Sx1,Sy1,'--')
    hold on
    x2=rand(1,4);
    y2=rand(1,4);
    ang=cart2pol((x2-mean(x2)),(y2-mean(y2)));
    [sortang,sortindex]=sort(ang);
    sx2=x2(sortindex);
    sy2=y2(sortindex);
    Sx2=[sx2,sx2(1)];
    Sy2=[sy2,sy2(1)];
    plot(Sx2,Sy2,'g-')

    判断多边形是否相交

    判断多边形是否相交,方法是判断是否存在相交的边。网上看到的方法,计算叉乘的只能用于判断直线是否相交,但不是适合判断线段。我想了好久,想到了也不是很简便的方法,就是求交点。对两条线段做插值,插值区间是两条线段取值范围的并集。matlab里面interp1函数对于样本点外的点,得到的值会是nan,这样插值后得到的相当于是一个分段函数,线段1得到分段函数的取值范围两个线段取值范围的并集,但是对于不包含在线段1本身的取值范围,得到的值使NAN。举例:

    线段一端点:(2,3)和(3,4)

    线段二端点:(1,4)和(2.5,3)

    取值范围的并集是[1 3],插值后,代表线段1的函数,取值范围是[1,3],在x<2时,取值为nan,在x>2时,取值则为原来的线段上的值,这样就可以了。

    function ifconter = findcounter(P1X,P1Y,P2X,P2Y)
        %% P1X,P1Y,P2X,P2Y分别是两个封闭图形的点
        ifconter=0;
        for i=1:length(P1X)-1
            for j=1:length(P2X)-1
                p1x=P1X(i:i+1)  ;
                p1y= P1Y(i:i+1)  ;
                p2x=P2X(j:j+1);
                p2y=  P2Y(j:j+1);
    %             figure(2);
    %             clf
    %             plot(P1X(i:i+1),P1Y(i:i+1));hold on
    %             plot(P2X(j:j+1),P2Y(j:j+1))
                AllX=linspace(min([p1x p2x]),max([p1x p2x]),100);    
                %% 插值
                 Int1 = interp1(p1x,p1y,AllX);
                 Int2 = interp1(p2x,p2y,AllX);
                 intersec=Int1-Int2;
                if(max(intersec)*min(intersec)<0)
                    ifconter=1;%有交点 返回1
                end
            end
        end
    end
    

    通过调用以上的函数,就可以判断两个多边形是否相交了。

    代码没有对时候包含进行判断,想要判断也很简答,只要调用inpolygon函数就可以了,这里就不赘述了。

    这个是我自己昨天接单子的时候遇到的实际问题,搜索了挺久也没有解决方法,自己想了一下,写出来了,于是就在这里分享一下。

    展开全文
  • 判断两个多边形是否相交 ,当前认为一个点相交也是相交,可针对凹多边形和凸边型等多复杂的多边形进行相交判断,采用java实现,因为网上java实现的比较少,所以这里写下如何实现,适用于碰撞检测,地图等等应用场景

    判断两个多边形是否相交 ,当前认为一个点相交也是相交,可针对凹多边形和凸边型等多复杂的多边形进行相交判断,采用java实现,因为网上java实现的比较少,所以这里写下如何实现,适用于碰撞检测,地图等等应用场景

    入口方法:intersectionJudgment

    package org.dxl;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.experimental.Accessors;
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collection;
    import java.util.List;
    
    /**
     * * @projectName launcher2
     * * @title Test
     * * @package org.dxl
     * * @description  判断两个多边形是否相交
     * * @author IT_CREAT     
     * * @date  2020 2020/11/5/005 22:06  
     * * @version
     */
    @Slf4j
    public class Test {
        /*
        第一步:快速排除,以某一个多边形参照物,沿着此多边形画矩形,用矩形将多边形包起来,
        在判断另一个多边形是否在这个矩形框中存在顶点,没有就说明另一个矩形一定在参照矩形框的外围。
        第二步:利用的是向量叉乘求两线段是否相交,这种求法是求的绝对相交(交叉相交),只要存在多边形任意两线段相交,就一定相交,
        同时还有一种情况,就是平行或者在延长线及线段上,这时候需要排除平行和在延长线上的情况
        第三步:用点射法求某一个顶点是否在某个多边形内部,这里需要同时同时判断多变形1上的所有点都在多边形2的内部或者边线段上,
        或者是反向多边形2的所有点在多边形1的内部或边线上,二者满足其一即可;
        */
        public static void main(String[] args) {
            Point point = new Point(0, 0.5);
            Polygon polygon = new Polygon().setPoints(Arrays.asList(
                    new Point(0, 0),
                    new Point(0, 0.5),
                    new Point(0.5, 0.5),
                    new Point(0.5, 0)
            ));
            // 点是否在内部
            boolean b = pointInPolygon(point, getLineSegment(polygon));
            System.out.println(b);
    
            Polygon polygon1 = new Polygon().setPoints(Arrays.asList(
                    new Point(-1, -1),
                    new Point(-1, 1),
                    new Point(1, 1),
                    new Point(1, -1)
            ));
            // 两个多边形相交
            System.out.println(intersectionJudgment(polygon, polygon1));
        }
    
        /**
         * 多边形相交判断(有一个点相交也认为相交)
         *
         * @param polygon1 多边形1
         * @param polygon2 多边形2
         * @return boolean
         */
        public static boolean intersectionJudgment(Polygon polygon1, Polygon polygon2) {
            if (isExistNull(polygon1, polygon2)) {
                return false;
            }
            if (isExistNullOrEmpty(polygon1.getPoints(), polygon2.getPoints())) {
                return false;
            }
            // 1、快速判断,如果不想交,则返回不相交
            if (!fastExclude(polygon1, polygon2)) {
                return false;
            }
            // 获取多边形线段集合
            List<LineSegment> lineSegment1 = getLineSegment(polygon1);
            List<LineSegment> lineSegment2 = getLineSegment(polygon2);
            // 存在线段集合任意一方为空,则不想交
            if (isExistNullOrEmpty(lineSegment1, lineSegment2)) {
                return false;
            }
            // 2、向量叉乘判断多边形是否存在线段相交,存在相交则返回相交
            if (crossJudgment(lineSegment1, lineSegment2)) {
                return true;
            }
            // 3、包含关系判断,分别两次判断,判断polygon1是否在polygon2内部和polygon2是否在polygon1内部,满足其一即可
            boolean isInclude = includeRelation(polygon1, lineSegment2);
            if (isInclude) {
                return true;
            }
            return includeRelation(polygon2, lineSegment1);
        }
    
        /**
         * 1、快速判断多边形是否相交
         *
         * @param polygon1 多边形1
         * @param polygon2 多边形2
         * @return boolean
         */
        private static boolean fastExclude(Polygon polygon1, Polygon polygon2) {
            // 多边形1
            double polygon1MaxX = polygon1.getPoints().get(0).getX();
            double polygon1MinX = polygon1.getPoints().get(0).getX();
            double polygon1MaxY = polygon1.getPoints().get(0).getY();
            double polygon1MinY = polygon1.getPoints().get(0).getY();
            for (Point point : polygon1.getPoints()) {
                polygon1MaxX = Math.max(polygon1MaxX, point.getX());
                polygon1MinX = Math.min(polygon1MinX, point.getX());
                polygon1MaxY = Math.max(polygon1MaxY, point.getY());
                polygon1MinY = Math.min(polygon1MinY, point.getY());
            }
    
            // 多边形2
            double polygon2MaxX = polygon2.getPoints().get(0).getX();
            double polygon2MinX = polygon2.getPoints().get(0).getX();
            double polygon2MaxY = polygon2.getPoints().get(0).getY();
            double polygon2MinY = polygon2.getPoints().get(0).getY();
            for (Point point : polygon2.getPoints()) {
                polygon2MaxX = Math.max(polygon2MaxX, point.getX());
                polygon2MinX = Math.min(polygon2MinX, point.getX());
                polygon2MaxY = Math.max(polygon2MaxY, point.getY());
                polygon2MinY = Math.min(polygon2MinY, point.getY());
            }
    
            // 我这里是人为临界点的点-点,点-线也是属于相交,(如过你认为不是,加上等于条件,也就是最大和最小出现任意相等也是不想交)
            // 1、多边形1的最大x比多边形2最小x还小,说明多边形1在多边形2左边,不可能相交
            // 2、多边形1的最小x比多边形2最大x还大,说明多边形1在多边形2右边,不可能相交
            // 3、多边形1的最大y比多边形2最小y还小,说明多边形1在多边形2下边,不可能相交
            // 4、多边形1的最小y比多边形2最大y还小,说明多边形1在多边形2上边,不可能相交
            return !(polygon1MaxX < polygon2MinX)
                    && !(polygon1MinX > polygon2MaxX)
                    && !(polygon1MaxY < polygon2MinY)
                    && !(polygon1MinY > polygon2MaxY);
        }
    
        /**
         * 获取线段集合
         *
         * @param polygon 多边形
         * @return 线段集合
         */
        private static List<LineSegment> getLineSegment(Polygon polygon) {
            List<LineSegment> lineSegments = new ArrayList<>();
            List<Point> points = polygon.getPoints();
            // 依次链接,形成线段
            for (int i = 0; i < points.size() - 1; i++) {
                Point previousElement = points.get(i);
                Point lastElement = points.get(i + 1);
                lineSegments.add(new LineSegment(previousElement, lastElement));
            }
            // 最后一组线段(最后一个点和初始点形成最后一条线段,形成闭环)
            if (lineSegments.size() > 0) {
                Point previousElement = points.get(points.size() - 1);
                Point lastElement = points.get(0);
                lineSegments.add(new LineSegment(previousElement, lastElement));
            }
            return lineSegments;
        }
    
        /**
         * 2、线段集合之间是否存在相交关系
         *
         * @param lineSegments1 线段集合1(其中一个多边形的线段集合)
         * @param lineSegments2 线段集合2(另一个多边形的线段集合)
         * @return boolean
         */
        private static boolean crossJudgment(List<LineSegment> lineSegments1, List<LineSegment> lineSegments2) {
            for (LineSegment lineSegment1 : lineSegments1) {
                for (LineSegment lineSegment2 : lineSegments2) {
                    // 任意一组线段相交及多边形相交,返回相交
                    if (calculationLineSegmentCrossing(lineSegment1, lineSegment2)) {
                        return true;
                    }
                }
            }
            return false;
        }
    
        /**
         * 线段是否相交(向量叉乘判断)
         *
         * @param lineSegment1 线段1
         * @param lineSegment2 线段2
         * @return boolean
         */
        private static boolean calculationLineSegmentCrossing(LineSegment lineSegment1, LineSegment lineSegment2) {
            // 如果存在任意一点在对方线段上,则相交
            if (isPointOnline(lineSegment1, lineSegment2)) {
                return true;
            }
            // 当不存端点在线段上,则进行交叉相交判断
            // A点
            Point aPoint = lineSegment1.getPrePoint();
            // B点
            Point bPoint = lineSegment1.getLastPoint();
            // C点
            Point cPoint = lineSegment2.getPrePoint();
            // D点
            Point dPoint = lineSegment2.getLastPoint();
            // AB向量叉乘AC向量
            double bc = crossProduct(aPoint, bPoint, aPoint, cPoint);
            // AB向量叉乘AD向量
            double bd = crossProduct(aPoint, bPoint, aPoint, dPoint);
            // CD向量叉乘CA向量
            double da = crossProduct(cPoint, dPoint, cPoint, aPoint);
            // CD向量叉乘CB向量
            double db = crossProduct(cPoint, dPoint, cPoint, bPoint);
            return bc * bd < 0 && da * db < 0;
        }
    
        /**
         * 两线段是否存在点在对方线段上
         *
         * @param lineSegment1 线段1
         * @param lineSegment2 线段2
         * @return boolean
         */
        private static boolean isPointOnline(LineSegment lineSegment1, LineSegment lineSegment2) {
            return isExistTrue(new boolean[]{
                    isCollinearIntersection(lineSegment1.getPrePoint(), lineSegment2),
                    isCollinearIntersection(lineSegment1.getLastPoint(), lineSegment2),
                    isCollinearIntersection(lineSegment2.getPrePoint(), lineSegment1),
                    isCollinearIntersection(lineSegment2.getLastPoint(), lineSegment1)});
        }
    
        /**
         * 点是否在线段上
         *
         * @param point            点
         * @param lineSegmentStart 线段起始点
         * @param lineSegmentEnd   线段尾点
         * @return boolean
         */
        private static boolean isCollinearIntersection(Point point, Point lineSegmentStart, Point lineSegmentEnd) {
            // 排除在延长线上的情况
            if (point.getX() >= Math.min(lineSegmentStart.getX(), lineSegmentEnd.getX())
                    && point.getX() <= Math.max(lineSegmentStart.getX(), lineSegmentEnd.getX())
                    && point.getY() >= Math.min(lineSegmentStart.getY(), lineSegmentEnd.getY())
                    && point.getY() <= Math.max(lineSegmentStart.getY(), lineSegmentEnd.getY())) {
                // 任意两点之间形成的向量叉乘等于0,表示在线段上或延长线上(三点共线)
                return crossProduct(point, lineSegmentStart, point, lineSegmentEnd) == 0;
            }
            return false;
        }
    
        /**
         * 点是否在线段上
         *
         * @param point       点
         * @param lineSegment 线段
         * @return boolean
         */
        private static boolean isCollinearIntersection(Point point, LineSegment lineSegment) {
            return isCollinearIntersection(point, lineSegment.getPrePoint(), lineSegment.getLastPoint());
        }
    
        /**
         * 3、多边形polygon的所有点是都在另一个多边形内部(包含关系)
         *
         * @param polygon      被包含(内部)多边形
         * @param lineSegments 包含(外部)多边形所有线段集合
         * @return boolean
         */
        private static boolean includeRelation(Polygon polygon, List<LineSegment> lineSegments) {
            List<Point> points = polygon.getPoints();
            // 所有点在内部或者线段上才算包含,返回包含关系,只要一个不满足,则返回不包含关系
            for (Point point : points) {
                if (!pointInPolygon(point, lineSegments)) {
                    return false;
                }
            }
            return true;
        }
    
        /**
         * 判断某个点是否在多边形内部
         *
         * @param point        点
         * @param lineSegments 多边形线段集合
         * @return boolean
         */
        private static boolean pointInPolygon(Point point, List<LineSegment> lineSegments) {
            // 点坐标
            double x = point.getX();
            double y = point.getY();
            // 交点个数
            int intersectionNum = 0;
            // 判断射线与多边形的交点个数
            for (LineSegment seg : lineSegments) {
                // 如果点在多边形边线上,则算在多边形内部
                if (isCollinearIntersection(point, seg.getPrePoint(), seg.getLastPoint())) {
                    return true;
                }
                double maxY = Math.max(seg.getPrePoint().getY(), seg.getLastPoint().getY());
                double minY = Math.min(seg.getPrePoint().getY(), seg.getLastPoint().getY());
                if (y >= minY && y < maxY) {
                    // 计算交点X坐标
                    double intersectionPointX = (y - seg.getPrePoint().getY()) * (seg.getLastPoint().getX() - seg.getPrePoint().getX())
                            / (seg.getLastPoint().getY() - seg.getPrePoint().getY()) + seg.getPrePoint().getX();
                    if (x > intersectionPointX) {
                        intersectionNum++;
                    }
                }
            }
            return intersectionNum % 2 != 0;
        }
    
        /**
         * 向量叉乘
         *
         * @param point1Start 向量1起点
         * @param point1End   向量1尾点
         * @param point2Start 向量2起点
         * @param point2End   向量2尾点
         * @return 向量叉乘结果
         */
        private static double crossProduct(Point point1Start, Point point1End, Point point2Start, Point point2End) {
            // 向量a
            double aVectorX = point1End.getX() - point1Start.getX();
            double aVectorY = point1End.getY() - point1Start.getY();
            // 向量b
            double bVectorX = point2End.getX() - point2Start.getX();
            double bVectorY = point2End.getY() - point2Start.getY();
            // 向量a叉乘向量b
            return aVectorX * bVectorY - bVectorX * aVectorY;
        }
    
        /**
         * 是否存在空对象
         *
         * @param objects 对象集合
         * @return boolean
         */
        private static boolean isExistNull(Object... objects) {
            for (Object object : objects) {
                if (object == null) {
                    return true;
                }
            }
            return false;
        }
    
        /**
         * 是否存在空集合
         *
         * @param collections 集合对象
         * @return boolean
         */
        private static boolean isExistNullOrEmpty(Collection<?>... collections) {
            for (Collection<?> collection : collections) {
                if (collection == null || collection.isEmpty()) {
                    return true;
                }
            }
            return false;
        }
    
        /**
         * 是否存在true
         *
         * @param booleans 布尔集合
         * @return boolean
         */
        private static boolean isExistTrue(boolean[] booleans) {
            for (boolean bool : booleans) {
                if (bool) {
                    return true;
                }
            }
            return false;
        }
    
        /**
         * 点
         */
        @Data
        @AllArgsConstructor
        @NoArgsConstructor
        private static class Point {
            private double x;
            private double y;
        }
    
        /**
         * 线段
         */
        @Data
        @AllArgsConstructor
        @NoArgsConstructor
        private static class LineSegment {
            private Point prePoint;
            private Point lastPoint;
        }
    
        /**
         * 多边形
         */
        @Data
        @AllArgsConstructor
        @NoArgsConstructor
        @Accessors(chain = true)
        private static class Polygon {
            private List<Point> points;
        }
    }
    

     

    展开全文
  • 判断多边形和多边形是否相交

    千次阅读 2019-11-22 16:37:34
    思路:判断多边形、线段是否和另一多边形相交,可先判断他们的控制矩形是否相交。然后再做点是否在多边形中的判断。【多边形的控制矩形,即能围住多边形的最小矩形。】 当矩形的边与多边形的顶点相交的时刻,不记为...

    python实现

    思路参考:https://bbs.csdn.net/topics/391070188

    思路:判断多边形、线段是否和另一多边形相交,可先判断他们的控制矩形是否相交。然后再做点是否在多边形中的判断。【多边形的控制矩形,即能围住多边形的最小矩形。】

    当矩形的边与多边形的顶点相交的时刻,不记为两图形相交。

    可用的测试代码如下:

    # !/usr/bin/python3.6
    # --coding:utf-8--
    # 多边形坐标值
    lsP = [(238, 204), (1079, 216), (1201, 662), (499, 649), (138, 469)]
    polygon_x_max, polygon_x_min, y_temp = max(lsP)[0], min(lsP)[0], [i[1] for i in lsP]
    polygon_y_max, polygon_y_min = max(y_temp), min(y_temp)
    # 矩形坐标值
    rectangle_x_max, rectangle_x_min = 1117, 785
    rectangle_y_max, rectangle_y_min = 716, 366
    rectangle_points = [[rectangle_x_min, rectangle_y_min], [rectangle_x_max, rectangle_y_min], [rectangle_x_min, rectangle_y_max], [rectangle_x_max, rectangle_y_max]]
    
    
    oddNodes = False
    # 判断矩形与多边形控制矩形是否相交
    # for point in rectangle_points:
    if (polygon_x_min < rectangle_x_max < polygon_x_max or polygon_x_min < rectangle_x_min < polygon_x_max) and (polygon_y_min < rectangle_y_min < polygon_y_max or polygon_y_min < rectangle_y_max < polygon_y_max):
        # 判断矩形顶点与多边形边的关系
        for point in rectangle_points:
            x, y = point[0], point[1]
            j = len(lsP) - 1
            for i in range(len(lsP)):
                if lsP[i][1] < y < lsP[j][1] or lsP[j][1] < y < lsP[i][1] and x >= lsP[i][0] or x >= lsP[j][0]:
                    if (lsP[i][0] + (y - lsP[i][1]) / (lsP[j][1] - lsP[i][1]) * (lsP[j][0] - lsP[i][0]))<x:
                        oddNodes = True
                j = i
    print(oddNodes)

    最后一个if判断的思路,利用两个三角形的比例关系求出交点在起点的左边还是右边;用图去理解如下。

    这是我看到别人博客画的很优秀的图,顺手复制过来的,哈哈…

    别人博客:https://www.jianshu.com/p/ba03c600a557

    如果有其他好的想法,还请不吝赐教~

    展开全文
  • 判断两个多边形是否相交相交

    千次阅读 2020-04-22 15:49:00
    //判断多边形线段是否相交 function isSegmentsIntersectant(segA, segB) {//线线 const abc = (segA[0][0] - segB[0][0]) * (segA[1][1] - segB[0][1]) - (segA[0][1] - segB[0][1]) * (segA[1][0]...
      // 1 判断相交
        //判断两多边形线段是否相交
        function isSegmentsIntersectant(segA, segB) {//线线
            const abc = (segA[0][0] - segB[0][0]) * (segA[1][1] - segB[0][1]) - (segA[0][1] - segB[0][1]) * (segA[1][0] - segB[0][0]);
            const abd = (segA[0][0] - segB[1][0]) * (segA[1][1] - segB[1][1]) - (segA[0][1] - segB[1][1]) * (segA[1][0] - segB[1][0]);
            if (abc * abd >= 0) {
                return false;
            }
            const cda = (segB[0][0] - segA[0][0]) * (segB[1][1] - segA[0][1]) - (segB[0][1] - segA[0][1]) * (segB[1][0] - segA[0][0]);
            const cdb = cda + abc - abd;
            console.log("线段是否相交:", !(cda * cdb >= 0));
            return !(cda * cdb >= 0);
        }
    
        function isPolygonsIntersectant(plyA, plyB) {//面面
            for (let i = 0, il = plyA.length; i < il; i++) {
                for (let j = 0, jl = plyB.length; j < jl; j++) {
                    const segA = [plyA[i], plyA[i === il - 1 ? 0 : i + 1]];
                    const segB = [plyB[j], plyB[j === jl - 1 ? 0 : j + 1]];
                    if (isSegmentsIntersectant(segA, segB)) {
                        console.log("边界相交:");
                        return true;
                    }
                }
            }
            console.log("边界不相交:");
            return false;
        }
    
    
        // 2 判断包含
        //判断点是否在另一平面图中
       
       function pointInPolygon(point, vs) {
    
            // https://github.com/substack/point-in-polygon
    
            const x = point[0], y = point[1];
    
            let inside = false;
            for (let i = 0, j = vs.length - 1; i < vs.length; j = i++) {
                const xi = vs[i][0], yi = vs[i][1];
                const xj = vs[j][0], yj = vs[j][1];
    
                const intersect = ((yi > y) !== (yj > y))
                    && (x < (xj - xi) * (y - yi) / (yj - yi) + xi);
                if (intersect) {
                    inside = !inside;
                }
            }
            console.log(inside);
            return inside;
        }
    
        //判断两多变形是否存在点与区域的包含关系(A的点在B的区域内或B的点在A的区域内)
        function isPointInPolygonBidirectional(plyA, plyB) {//面面
            let [a, b] = [false, false];
            a = plyA.some(item => pointInPolygon(item, plyB));
            if (!a) {
                b = plyB.some(item => pointInPolygon(item, plyA));
            }
            console.log("包含关系:", a || b);
            return a || b;
        }
    
        // 3 判断多边形是否重合
        function isPolygonsOverlap(plyA, plyB) {
            return isPolygonsIntersectant(plyA, plyB) || isPointInPolygonBidirectional(plyA, plyB);
        }
    
        // const plyA = [[109.12560386473433, 333.99033816425117],[367.90096618357484, 333.99033816425117],[239.1570048309178, 462.7342995169082]],
        // plyB = [[122.78502415458934, 261.3623188405797],[187.1570048309178, 325.7342995169082],[122.78502415458934, 390.10628019323667]];
        const plyA = [
            [
              90.703125,
              67.47492238478702
            ],
            [
              87.1875,
              67.06743335108298
            ],
            [
              81.5625,
              50.958426723359935
            ],
            [
              46.7578125,
              39.639537564366684
            ],
            [
              113.5546875,
              39.095962936305476
            ],
            [
              130.78125,
              67.06743335108298
            ],
            [
              90.703125,
              67.47492238478702
            ]
          ]
            plyB =          [
            [
              75.5859375,
              52.696361078274485
            ],
            [
              79.8046875,
              67.60922060496382
            ],
            [
              29.179687499999996,
              63.54855223203644
            ],
            [
              -1.7578125,
              35.746512259918504
            ],
            [
              0.3515625,
              4.214943141390651
            ],
            [
              51.67968749999999,
              -13.2399454992863
            ],
            [
              56.25,
              30.44867367928756
            ],
            [
              21.09375,
              32.54681317351514
            ],
            [
              41.1328125,
              44.84029065139799
            ],
            [
              75.5859375,
              52.696361078274485
            ]
          ]
    
    
            ;
    
        const isOver = isPolygonsOverlap(plyA, plyB);
        console.log(isOver)
    
    展开全文
  • 比如:判断地图中的多边形多边形是否相交。我在项目中具体的需求就是如此,需要过滤某个区域的瓦片地图。先把瓦片地图反向解析成Envolope,然后和该区域进行比对,再做其他处理。  其实在已经有开源的东西GDAL...
  • 概念:通过判断任意两个凸多边形在任意角度下的投影是否均存在重叠,来判断是否发生碰撞。若在某一角度光源下,两物体的投影存在间隙,则为不碰撞,否则为发生碰撞。 图例: 在程序中,遍历所有角度是不现实的。...
  • 本文基础是地球坐标系下判断线段相交,请参考 http://blog.csdn.net/philipzeng/archive/2010/07/22/5754339.aspx<br />能判断线段相交了,多边形相交问题也就迎刃而解。   class ...
  • 原文地址 http://www.cnblogs.com/topcss/p/3575248.html ,基于该作者的代码基础上进行简单修改,使其在openlayers3上可用,有兴趣可以去看一下
  • 温馨提示微信公众号又双叒叕改版了...微课视频第一课时微课视频第二课时知识点同步练习参考答案教学设计相交与垂直。(教材第18~19页)1.借助实际情境和操作活动,认识垂直。2.能用三角尺画垂线。3.能根据点与线之间“...
  • 主要介绍了Python判断直线和矩形是否相交的方法,涉及Python坐标系下的直线与矩形相关运算,具有一定参考借鉴价值,需要的朋友可以参考下
  • int check(Node a,Node b)///判断多边形a是否和多边形b相交,注意内含算不相交 { a.d[a.num]=a.d[0]; b.d[b.num]=b.d[0]; for(int i=0; i; i++) for(int j=0; j; j++) if(inter(a.d[i],a.d[i+1],b.d[j],b.d[j+1...
  • 判断2个多边形相交

    千次阅读 2020-03-06 15:21:32
    2个多边形的边是否相交。 点在内部。2个多边形的顶点是否在另一个多边形的内部。 关于这2个条件的判断: 《碰撞检测:判断是否多边形内部》 https://blog.csdn.net/StevenKyleLee/article/details/88044589 ...
  • 简单多边形的相交、合并算法。...这个demo程序只是介绍了多边形相交、合并的算法,针对简单凹凸多边形可以正常处理。算法仅供参考! 如需要支持内部有环的复杂多边形相交合并,请使用boost::polygon。
  • 多边形凹凸性的判断、自相交判断

    千次阅读 2020-09-12 09:53:58
    该博文转载自 弱花3kou 的文章 [OpenGL] 绘制并且判断凹凸多边形、自相交多边形 分析 凸多边形多边形相交 代码 #include <iostream> #include <ctime> #include <math.h> #...
  • //aa, bb为一条线段两端点 cc, dd为另一条线段的两端点 相交返回true, 不相交返回false bool intersect(MapPoint aa, MapPoint bb, MapPoint cc, MapPoint dd) { if (Math.Max(aa.x, bb.x) (cc.x, dd.x)) { ...
  • 判断两个凸多边形是否相交—SAT

    千次阅读 2018-04-26 16:39:14
    介绍https://www.codeproject.com/Articles/15573/D-Polygon-Collision-Detection应用分离轴定理 SAT ,看是否能找到分离轴,如果能找到那么就是不相交。否则相交。利用点积的几何意义: 投影源码判断 polya 和 ...
  • //判断多边形边界是否相交 function isPolygonsIntersectant($plyA, $plyB) {//面面 for ($i = 0, $il = count( $plyA ); $i < $il; $i++) { for ($j = 0, $jl = count( $plyB ); $j < $jl; $j++)...
  • line2 = wkt.loads("LINESTRING (116.23761690616871 40.17092015348095, 116.23760690616871 40.17092015348095)") # 判断线线是否相交 print(line1.intersects(line2)) # 增加0.3米的buffer, 这里0.3/100000后的...
  • 碰撞检测:判断2个多边形相交

    千次阅读 2019-03-02 14:41:09
    演示demo: 需要判断2个条件 边相交。2个多边形的边是否相交。 点在内部。2个多边形的顶点是否在另一个多边形的内部。 关于这2个条件的判断: 《碰撞检测:判断是否多边形内部》 ...
  • 多边形相交检测demo

    2019-03-02 14:42:51
    本资源对应的博文地址:https://blog.csdn.net/StevenKyleLee/article/details/88075814
  • python 判断多边形,点是否重合 首先代码并未使用 cv2.pointPolygonTest 这一opencv函数,因为自己在使用时,一直报错,很难自己构造出适用于 pointPolygonTest ()的 tuple参数,然后在网上找到了如下这边博客写的...
  • 扫线法快速判断多边形相交

    千次阅读 2020-01-08 00:55:14
    这个开源库基于Unity开发,主要实现了凹多边形之间的相交判断,当然也可以应用于顶点与凹凸包、线段与凹凸包、凸包与凸包之间的相交判断,也就是说,这个方案基本可以解决前面两则文章中的所有多边形判断,效率也...
  • 判断平面内点是否多边形内有多种算法,其中射线法是其中比较好理解的一种,而且能够支持凹多边形的情况。该算法的思路很简单,就是从目标点出发引一条射线,看这条射线和多边形所有边的交点数目。如果有奇数个交点...
  • 真的很讨厌,数学不是太好,但是几何还好,纵使是这样,该忘了的还是忘了...为了解决在百度API中缺少图形是否相交判断,所以必须,要判断两个图形边缘的点,这下问题就来了, 网上搜一大片,全是绘制View的,找了很
  • 判断线段相交及点是否多边形

    热门讨论 2011-10-08 08:50:50
    算法导论里面的关于线段是否相交以及点是否多边形内的判断的源代码,另包含一个说明文档~
  • 三、Geos库的安装和计算多边形是否相交 1.Geos库的安装 1.1 2.计算多边形是否相交(C语言) 你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章,...
  • 判断新生成的area是否为空 代码: import java.awt.Polygon; import java.awt.geom.Area; Polygon p = new Polygon(new int[]{1,1,3,3},new int[]{0,1,1,0},4); Polygon p1 = new Poly
  • //判断线段p1p2, 线段q1q2是否相交 int intersection(Point p1 , Point p2 ,Point q1 , Point q2){ double d1 = (p2 - p1) ^ (q1 - p1) ; double d2 = (p2 - p1) ^ (q2 - p1) ; double d3 = (q2 - q1) ^ (p1 - ...
  • 【C++】任意两个多边形相交问题

    千次阅读 2020-07-23 12:59:03
    那么,判断f1和f2是否相交,可以将每条边用解析式表示,将两个多边形的边的解析式联立算交点,并将交点与解析式的取值范围相匹配,即可解决此问题。 解析式为y=kx+b,两点为(x1,y1),(x2,y2),那么 k=y1−y2x1−x2k...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,648
精华内容 3,059
关键字:

判断多边形是否相交