• Python处理矩形和圆的关系，处理矩形和多边形的关系

    目录

    一、基本思路

    二、矩形和圆的关系

    验证思路

    三、矩形和多边形的关系

    验证思路：

    一、基本思路

    本文主要处理的是相交和不相交，因为地理数据保存较多，需要运用最小外接矩阵

    1.根据radius_2_coordinate方法获得圆的最小外接矩阵

    1. # 获取多边形的最小外接矩阵            
    2. max = np.max(num['polygonArr'], axis=0)
    3. min = np.min(num['polygonArr'], axis=0)

    2.筛选原矩阵与最小外接矩阵的交集

    3.循环交集的内容,使用intersect_check_garden验证圆，使用intersect_check_polygon验证多边形

    二、矩形和圆的关系

    验证思路

    圆和矩阵存在多种关系：圆在矩阵内，圆与矩阵相交，矩阵在圆内，圆与矩阵不相交。我的实际需求分析后发现，矩阵在园内与圆与矩阵相交可以同时验证。

    1.圆在矩阵内

    主要使用isInPolygon方法判断圆的圆心是否在矩阵内。

    2.圆与矩阵相交，矩阵在圆内

    运用的主要思路：计算圆心到矩阵四个边的最短距离，与圆的半径比较，存在小于半径的值，就是圆与矩阵相交，矩阵在圆内关系，反之，圆与矩阵不相交

    1. import numpy as np
    2. import math
    3. from math import cos
    4.  
    5.  
    6. def coordinate_2_radius(Longitude, Latitude):
    7.     '''
    8.     参考地址：https://blog.csdn.net/Dust_Evc/article/details/102847870?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-7.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-7.control
    9.     度数与弧度转化公式：1°=π/180°，1rad=180°/π。
    10.     地球半径：6371000M
    11.     地球周长：2 * 6371000M  * π = 40030173
    12.     纬度38°地球周长：40030173 * cos38 = 31544206M
    13.     任意地球经度周长：40030173M
    14.     经度（东西方向）1M实际度：360°/31544206M=1.141255544679108e-5=0.00001141
    15.     纬度（南北方向）1M实际度：360°/40030173M=8.993216192195822e-6=0.00000899
    16.     '''
    17.     # R = 6371000
    18.     # L = 2 * math.pi * R
    19.     Lng_l = 40030173  # 当前经度地球周长
    20.     Lat_l = Lng_l * cos(Latitude * math.pi / 180)  # 当前纬度地球周长，弧度转化为度数
    21.     # print(Lat_l)
    22.     Lat_C = Lat_l / 360
    23.     Lng_C = Lng_l / 360
    24.     Latitude_m = Latitude * Lat_C
    25.     Longitude_m = Longitude * Lng_C
    26.     return Latitude_m, Longitude_m
    27.  
    28.  
    29. def radius_2_coordinate(Longitude, Latitude, radius):
    30.     '''
    31.     参考地址：https://blog.csdn.net/Dust_Evc/article/details/102847870?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-7.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-7.control
    32.     度数与弧度转化公式：1°=π/180°，1rad=180°/π。
    33.     地球半径：6371000M
    34.     地球周长：2 * 6371000M  * π = 40030173
    35.     纬度38°地球周长：40030173 * cos38 = 31544206M
    36.     任意地球经度周长：40030173M
    37.     经度（东西方向）1M实际度：360°/31544206M=1.141255544679108e-5=0.00001141
    38.     纬度（南北方向）1M实际度：360°/40030173M=8.993216192195822e-6=0.00000899
    39.     '''
    40.     Lng_l = 40076000  # 当前经度地球周长
    41.     Lat_l = Lng_l * cos(Latitude * math.pi / 180)  # 当前纬度地球周长，弧度转化为度数
    42.     Lat_C = Lat_l / 360
    43.     Lng_C = Lng_l / 360
    44.     radius_lat = radius / Lat_C
    45.     radius_lng = radius / Lng_C
    46.     # print(radius_lng, radius_lat)
    47.     return radius_lat, radius_lng
    48.  
    49.  
    50. def isInPolygon(point, polygon):  ##  检测点是否在多边形内，输入([x,y], polygon_list也就是点组成的list)
    51.     # 使用水平射线检测
    52.     x, y = point[0], point[1]
    53.     nCross = 0
    54.     for i in range(len(polygon)):
    55.         p1 = polygon[i]
    56.         p2 = polygon[(i + 1) % len(polygon)]
    57.         # 特殊情况：边界p1p2 与 y=p0.y平行，不计数
    58.         if (p1[1] == p2[1]): continue
    59.         # 交点在p1p2延长线上，注意是小于，不计数
    60.         if (y < min(p1[1], p2[1])): continue
    61.         # 交点在p1p2延长线上，注意是大于等于，不计数
    62.         if (y >= max(p1[1], p2[1])): continue
    63.         # 求交点的 X 坐标；根据相似三角形计算
    64.         crossx = (y - p1[1]) * (p2[0] - p1[0]) / (p2[1] - p1[1]) + p1[0]
    65.         # 只统计单边交点
    66.         if (crossx >= x):
    67.             nCross = nCross + 1
    68.     # min_dis = get_dis_point2polygon(point, polygon)
    69.     # if abs(min_dis)<1e-2:  ##  求点到哪个边距离最小，是否为0，为0则表示在边界上
    70.     #     return 1
    71.     return (nCross % 2 == 1)
    72.  
    73.  
    74. def get_nearest_distance(point, line):
    75.     # 获取线段 与 点的最短距离
    76.     # print('get_nearest_distance')
    77.  
    78.     def get_foot(point, line):
    79.         # 获取直线 与 点的垂足
    80.         start_x, start_y = line[0], line[1]
    81.         end_x, end_y = line[2], line[3]
    82.         pa_x, pa_y = point
    83.  
    84.         p_foot = [0, 0]
    85.         if line[0] == line[3]:
    86.             p_foot[0] = line[0]
    87.             p_foot[1] = point[1]
    88.             return p_foot
    89.         k = (end_y - start_y) * 1.0 / (end_x - start_x)
    90.         a = k
    91.         b = -1.0
    92.         c = start_y - k * start_x
    93.         p_foot[0] = (b * b * pa_x - a * b * pa_y - a * c) / (a * a + b * b)
    94.         p_foot[1] = (a * a * pa_y - a * b * pa_x - b * c) / (a * a + b * b)
    95.         return p_foot
    96.  
    97.     def get_nearest_point(point, line):
    98.         #  计算点到线段的最近点
    99.         pt1_x, pt1_y = line[0], line[1]
    100.         pt2_x, pt2_y = line[2], line[3]
    101.         point_x, point_y = point[0], point[1]
    102.         if (pt2_x - pt1_x) != 0:
    103.             k = (pt2_y - pt1_y) / (pt2_x - pt1_x)
    104.             # 该直线方程为：
    105.             # y = k* ( x - pt1_x) + pt1_y
    106.             # 其垂线的斜率为 - 1 / k，
    107.             # 垂线方程为：
    108.             # y = (-1/k) * (x - point_x) + point_y
    109.             # 联立两直线方程解得：
    110.             x = (k ** 2 * pt1_x + k * (point_y - pt1_y) + point_x) / (k ** 2 + 1)
    111.             y = k * (x - pt1_x) + pt1_y
    112.             return (x, y)
    113.         elif min(pt1_y, pt2_y) < point[1] < max(pt1_y, pt2_y):
    114.             return get_foot(point, line)
    115.         else:
    116.             l1 = np.hypot(pt1_y - point[1], pt1_x - point[0])
    117.             l2 = np.hypot(pt2_y - point[1], pt2_x - point[0])
    118.             return (pt1_x, pt1_y) if l1 < l2 else (pt2_x, pt2_y)
    119.  
    120.     nearest_point = get_nearest_point(point, line)
    121.     # print(nearest_point)
    122.     x, y = coordinate_2_radius(nearest_point[0], nearest_point[1])
    123.     point_x, point_y = coordinate_2_radius(point[0], point[1])
    124.     distance = math.sqrt((x - point_x) * (x - point_x) + (y - point_y) * (y - point_y))
    125.     # print(nearest_point[0], nearest_point[1], point[0], point[1], distance)
    126.     return distance
    127.  
    128.  
    129. def intersect_check_garden(point_lng, point_lat, radius, q1_x, q1_y, q2_x, q2_y, q3_x, q3_y, q4_x, q4_y):
    130.     """
    131.     与园的相交检查
    132.     """
    133.     # print('intersect_check_garden')
    134.     radius_lng, radius_lat = radius_2_coordinate(point_lng, point_lat, radius)
    135.  
    136.     # point_lng_max = point_lng + radius_lng
    137.     # point_lng_min = point_lng - radius_lng
    138.     # point_lat_max = point_lat + radius_lat
    139.     # point_lat_min = point_lat - radius_lat
    140.     # # 1.圆在图形内
    141.     # xmin = min(q1_x, q2_x, q3_x, q4_x)
    142.     # xmax = max(q1_x, q2_x, q3_x, q4_x)
    143.     # ymin = min(q1_y, q2_y, q3_y, q4_y)
    144.     # ymax = max(q1_y, q2_y, q3_y, q4_y)
    145.     if isInPolygon([point_lng, point_lat], [[q1_x, q1_y], [q2_x, q2_y], [q3_x, q3_y], [q4_x, q4_y]]):
    146.         print("圆在图形内")
    147.         return True
    148.  
    149.     # if xmin < point_lng_max < xmax and xmin < point_lng_min < xmax:
    150.     #     return True
    151.     #
    152.     # if ymin < point_lat_max < ymax and ymin < point_lat_min < ymax:
    153.     #     return True
    154.     # 2.圆与图形相交为True,圆在图形不想交相交为False,
    155.     distance1 = get_nearest_distance([point_lng, point_lat], [q1_x, q1_y, q2_x, q2_y])
    156.     if distance1 < radius:
    157.         return True
    158.     distance2 = get_nearest_distance([point_lng, point_lat], [q2_x, q2_y, q3_x, q3_y])
    159.     if distance2 < radius:
    160.         return True
    161.     distance3 = get_nearest_distance([point_lng, point_lat], [q3_x, q3_y, q4_x, q4_y])
    162.     if distance3 < radius:
    163.         return True
    164.     distance4 = get_nearest_distance([point_lng, point_lat], [q4_x, q4_y, q1_x, q1_y])
    165.     if distance4 < radius:
    166.         return True
    167.     distance5 = get_nearest_distance([point_lng, point_lat], [q1_x, q1_y, q3_x, q3_y])
    168.     if distance5 < radius:
    169.         return True
    170.     distance6 = get_nearest_distance([point_lng, point_lat], [q2_x, q2_y, q4_x, q4_y])
    171.     if distance6 < radius:
    172.         return True
    173.     return False

    三、矩形和多边形的关系

    本文主要处理的是相交和不相交，基本思路：

    验证思路：

    多边形和矩阵存在多种关系：多边形在矩阵内，多边形与矩阵相交，矩阵在多边形内，多边形与矩阵不相交。我的实际需求分析后发现，矩阵在多边形内和多边形与矩阵相交可以同时验证。

    1.多边形在矩阵内

    主要使用isInPolygon方法判断圆的圆心是否在矩阵内。

    2.多边形与矩阵相交，矩阵在多边形内

    思路：根据矩阵的4个点左边，生成4条线段，根据line_polygon方法判断线段与多边形的关系（根据实际需要等分，我这里是10等分,每个点计算与多边形的关系）

    1. def intersect_check_polygon(polygon, q1_x, q1_y, q2_x, q2_y, q3_x, q3_y, q4_x, q4_y):
    2.     """
    3.     与多边形的相交检查
    4.     polygon:多边形的list
    5.     """
    6.  
    7.     def get_points(start_x, start_y, end_x, end_y):
    8.         # print(start_x, start_y, end_x, end_y)
    9.         if end_x - start_x != 0:
    10.             k = (end_y - start_y) * 1.0 / (end_x - start_x)
    11.             # y = start_y + k * (x - start_x)  # 2个点组成的直线
    12.             division = 10  # 线段切割次数
    13.             point_list = []  # 线段上点的集合
    14.             for i in range(0, division):
    15.                 x = start_x * i / 10 + start_x
    16.                 if x < end_x:
    17.                     y = start_y + k * (x - start_x)
    18.                     point_list.append([x, y])
    19.             return point_list
    20.  
    21.     def line_polygon(polygon, start_x, start_y, end_x, end_y):
    22.         # 线段是否与多边形相交
    23.         points = get_points(start_x, start_y, end_x, end_y)
    24.         if points:
    25.             for point in get_points(start_x, start_y, end_x, end_y):
    26.                 if isInPolygon(point, polygon):
    27.                     return True
    28.         return False
    29.  
    30.     # 1.多边形在图形内
    31.     if isInPolygon([polygon[0][0], polygon[0][1]], [[q1_x, q1_y], [q2_x, q2_y], [q3_x, q3_y], [q4_x, q4_y]]):
    32.         print("多边形在图形内")
    33.         return True
    34.  
    35.     # 2.图形与多边的相交为True，其他为False
    36.     if line_polygon(polygon, q1_x, q1_y, q2_x, q2_y):
    37.         return True
    38.     if line_polygon(polygon, q2_x, q2_y, q3_x, q3_y):
    39.         return True
    40.     if line_polygon(polygon, q1_x, q1_y, q2_x, q2_y):
    41.         return True
    42.     if line_polygon(polygon, q3_x, q3_y, q4_x, q4_y):
    43.         return True
    44.     if line_polygon(polygon, q2_x, q2_y, q4_x, q4_y):
    45.         return True
    46.     if line_polygon(polygon, q1_x, q1_y, q3_x, q3_y):
    47.         return True
    48.     return False

    参考链接：

    python进行点和线段、直线、多边形的交点、距离，垂直等处理——代码_nature1949的博客-CSDN博客_python两点求直线方程

    经纬度和米的换算_Dust_Evc的博客-CSDN博客_经纬度和米的换算

  • 相关阅读:
    时空数据挖掘二（城市计算）
    哈夫曼树哈夫曼编码知识点
    java计算机毕业设计企业公开招聘系统源码+数据库+系统+lw文档+mybatis+运行部署
    Jenkins部署的Windows爬虫机如何配置
    Nacos配置
    文件部署到服务器
    解决storybook中组件的tailwindcss类不生效问题
    MFC删除Button控件具体操作
    Allegro如何快速将目标旋转90度操作指导
    【Linux】最新CentOS8内核升级
  • 原文地址：https://blog.csdn.net/qq_15028721/article/details/126975704