1.点到点的距离

首先最简单的是两点之间的距离，直接用距离公式即可

import math
import matplotlib.pyplot as plt
def point_to_point(x1, y1, x2, y2):
    lineMagnitude = math.sqrt(math.pow((x2 - x1), 2) + math.pow((y2 - y1), 2))
    return lineMagnitude

2.点到线段的距离

关键在于判断点在直线上的投影在线段外还是线段内(通过向量方法计算AP在AB上的投影u)，如果在线段内(0≤u≤1)，则返回点到直线的距离；如果在线段外(u<0 or u>1)，直接计算点到两端点距离取最小值

# 计算点P(px,py)到线段A(x1,y1)B(x2,y2)之间的最短距离
def point_to_line(px, py, x1, y1, x2, y2):
    line_magnitude = point_to_point(x1, y1, x2, y2)
    if line_magnitude < 0.00000001:
        #如果线段距离很近，直接返回P到A的距离
        return point_to_point(px, py, x1, y1)
    u1 = (((px - x1) * (x2 - x1)) + ((py - y1) * (y2 - y1))) #向量AB·向量AP
    u = u1 / (line_magnitude * line_magnitude) #向量AP在向量AB方向的投影与向量AB模的比值
    if (u < 0) or (u > 1):
        # 点到直线的投影不在线段内, 计算点到两个端点距离的最小值即为"点到线段最小距离"
        return min(point_to_point(px, py, x1, y1),point_to_point_distance(px, py, x2, y2))
    # 投影点在线段内部, 计算方式同点到直线距离, u 为投影点距离x1在x1x2上的比例, 以此计算出投影点的坐标
    ix = x1 + u * (x2 - x1)
    iy = y1 + u * (y2 - y1)
    return point_to_point(px, py, ix, iy)

3.点到垂直矩形之间的最短距离

垂直矩形即矩形的各边垂直于坐标轴，通过左上和右下两个点坐标即可确定

首先判断点是否在矩形内或矩形边上，如果是则距离为0，如果点在矩形外，则点到矩形四边距离最小值即为点到矩形最小距离

# 计算点P(px,py)到垂直矩形A(x1,y1)B(x2,y2)之间的最短距离
def point_to_rectangle(px, py, x1, y1, x2, y2):
    if px > min(x1,x2) and px < max(x1,x2) and py > min(y1,y2) and py < max(y1,y2):
        #点在矩形内
        return 0
    distance1 = point_to_line(px, py, x1, y1, x1, y2)
    distance2 = point_to_line(px, py, x1, y1, x2, y1)
    distance3 = point_to_line(px, py, x2, y2, x1, y2)
    distance4 = point_to_line(px, py, x2, y2, x2, y1)
    return min(distance1,distance2,distance3,distance4)

4.点到任意凸多边形的最短距离

更一般的情况，需计算点到任意凸多边形的最短距离，凸多边形的定义：没有任何一个内角是优角（Reflexive Angle）的多边形，如下图所示

#多边形画图展示
import matplotlib.pyplot as plt
poly1 = ((1,0.5),(1.5,2.5),(2,2),(1.5,3),(0.1,1))
poly2 = ((1,0.5),(1.8,1),(2,2),(1.5,3),(0.1,1))
fig = plt.figure(figsize=(10,5))
plt.rcParams['font.sans-serif']=['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus']=False # 用来正常显示负号
ax1 = fig.add_subplot(1,2,1)
plt.title('凹多边形')
polygon = plt.Polygon(xy=poly1, color='blue', alpha=0.3)
ax1.add_patch(polygon)
xylim = max(max(i) for i in poly1)*1.1
ax1.set_ylim(0,xylim)
ax1.set_xlim(0,xylim)
ax2 = fig.add_subplot(1,2,2)
plt.title('凸多边形')
polygon2 = plt.Polygon(xy=poly2, color='blue', alpha=0.3)
ax2.add_patch(polygon2)
xylim = max(max(i) for i in poly2)*1.1
ax2.set_ylim(0,xylim)
ax2.set_xlim(0,xylim)
plt.savefig('poly.png')
plt.show()

计算思路与矩形类似，首先判断点是否在多边形内或多边形边上，如果是则距离为0，如果点在多边形外，则点到多边形各边距离最小值即为点到多边形的最小距离

4.1判断是否为凸多边形

根据凸多边形的特性判断：如果把一个多边形的所有边中，有一条边向两方无限延长成为一直线时，其他各边都在此直线的同旁，那么这个多边形就叫做凸多边形。

#计算直线表达式，返回直线的类别及其描述参数
def kb(vertex1, vertex2):
    x1,y1 = vertex1
    x2,y2 = vertex2
    if x1==x2:
        return (0, x1)      # 0-垂直直线
    if y1==y2:              
        return (1, y1)      # 1-水平直线
    else:
        k = (y1-y2)/(x1-x2)
        b = y1 - k*x1
        return (2, k, b)    # 2-倾斜直线

#判断多边形为凸多边形
def isConvex(poly):
    # 默认为凸多边形
    convex = True
    poly_num = len(poly)

    # 对每两个点组成的直线做判断
    for i in range(poly_num):
        j = (i+1)%poly_num
        # 得到直线
        line = kb(poly[i], poly[j])
        # 计算所有点和直线的距离（可能为正也可能为负）
        if line[0]==0:
            offset = [vertex[0]-poly[i][0] for vertex in poly]
        elif line[0]==1:
            offset = [vertex[1]-poly[i][1] for vertex in poly]
        else:
            k, b = line[1], line[2]
            offset = [k*vertex[0]+b-vertex[1] for vertex in poly]
        
        # 计算两两距离的乘积，如果出现负数则存在两个点位于直线两侧，因此为凹多边形
        for o in range(len(offset)-1):
            if offset[o]*offset[o+1] < 0:
                convex = False
                break
        if convex==False:
            break
    if convex==False:        
        #画图展示
        fig = plt.figure(figsize=(5,5))
        ax1 = fig.add_subplot(1,1,1)
        polygon = plt.Polygon(xy=poly, color='blue', alpha=0.3)
        ax1.add_patch(polygon)
        X = [point[0] for point in poly]
        Y = [point[1] for point in poly]
        plt.scatter(X,Y,c='blue')
    #     plt.scatter([px],[py],c='red')
        xylim = max(max(i) for i in poly)*1.1
        ax1.set_ylim(0,xylim)
        ax1.set_xlim(0,xylim)
        plt.show()
    return convex

4.2判断点在多边形内

利用向量叉乘的方法判断：

#判断点是否在凸多边形内部
def isinpolygon(px, py, poly):
    #poly为多边形坐标，按顺时针或逆时针排列
    z=[] #每个顶点和P点的连线向量和该定点和下一个顶点向量的叉积
    poly_num = len(poly) #多边形的边数
    if poly_num <=1:
        return False
    for i in range(poly_num):
        j = (i+1)%(poly_num) #j为下一个顶点序号
        z.append((poly[j][0]-poly[i][0])*(py-poly[i][1]) - (px-poly[i][0])*(poly[j][1]-poly[i][1])) #计算叉积
    #叉乘结果若全部同号，则返回真，否则返回假
    for k in range(len(z)-1):
        if z[k]*z[k+1] < 0:
            return False
    return True

4.3计算点到多边形的距离

# 计算点P(px,py)到任意凸多边形之间的最短距离
def point_to_polygon(px, py, poly):
    if not isConvex(poly):
        raise ValueError("凹多边形无法计算！")
    if isinpolygon(px, py, poly):
        min_distance = 0
    else:
        distance = [] #点到每边的最短距离
        poly_num = len(poly) #多边形的边数
        for i in range(poly_num):
            j = (i+1)%(poly_num) #j为下一个顶点序号
            distance.append(point_to_line(px, py, poly[i][0], poly[i][1], poly[j][0], poly[j][1]))
        min_distance = min(distance)
    #画图展示
    fig = plt.figure(figsize=(5,5))
    ax1 = fig.add_subplot(1,1,1)
    polygon = plt.Polygon(xy=poly, color='blue', alpha=0.5)
    ax1.add_patch(polygon)
    X = [point[0] for point in poly]
    Y = [point[1] for point in poly]
    plt.scatter(X,Y,c='blue')
    plt.scatter([px],[py],c='red')
    xylim = max(px,py,max(max(i) for i in poly))*1.1
    ax1.set_ylim(0,xylim)
    ax1.set_xlim(0,xylim)
    plt.show()
    return min_distance

5.测试：

point_to_polygon(1,1,((1,0.5),(2,1),(2,2),(1.5,3),(0.1,1)))

输出：0

point_to_polygon(2.5,0.5,((1,0.5),(2,1),(2,2),(1.5,3),(0.1,1)))

输出：0.7071067811865476

point_to_polygon(1,1,((1,0.5),(1.5,1.8),(2,2),(1.5,3),(0.1,1)))

输出：ValueError: 凹多边形无法计算！

#两个点的多边形，即为点到线段的距离
point_to_polygon(0.5,0.5,[[1,0.2],[2,2]])

输出：0.5827715174143584

#1个点的多边形，即为点到点的距离
point_to_polygon(0.5,0.5,[[1,0.5]])

 输出：0.5

特殊的垂直矩形，也可以用一般点到多边形方法来计算：

# 用点到多边形的方法计算点P(px,py)到垂直矩形A(x1,y1)B(x2,y2)之间的最短距离
def point_to_rectangle2(px, py, x1, y1, x2, y2):
    poly = ((x1,y1),(x1,y2),(x2,y2),(x2,y1))
    return point_to_polygon(px,py,poly)