写一份生成随机简单多边形的代码

以下是一份生成随机简单多边形的代码，使用 Python 语言实现：

import random

def generate_polygon(num_vertices, min_coord, max_coord):
    vertices = []
    for i in range(num_vertices):
        x = random.randint(min_coord, max_coord)
        y = random.randint(min_coord, max_coord)
        vertices.append((x, y))
    vertices.sort()
    vertices.append(vertices[0])
    return vertices

if __name__ == '__main__':
    num_vertices = 5
    min_coord = 0
    max_coord = 10
    polygon = generate_polygon(num_vertices, min_coord, max_coord)
    print(polygon)

这份代码使用了 Python 的 random 模块生成了一组随机的顶点坐标，然后按照 x 坐标从小到大的顺序排序，并在最后再添加一次第一个顶点，以保证生成的多边形是简单多边形。

相关问题

写一份生成随机简单多边形的代码，要求可以生成任意简单多边形

以下是一份生成随机简单多边形的代码，可以生成任意简单多边形：

import random

def generate_polygon(n, min_x, max_x, min_y, max_y):
    points = []
    for i in range(n):
        x = random.uniform(min_x, max_x)
        y = random.uniform(min_y, max_y)
        points.append((x, y))
    points.sort()
    lower = points[:2]
    upper = points[2:]
    random.shuffle(lower)
    random.shuffle(upper)
    points = lower + upper
    while True:
        i = random.randint(0, n-1)
        j = random.randint(0, n-1)
        if i == j:
            continue
        a, b = points[i], points[j]
        valid = True
        for k in range(n):
            if k == i or k == j:
                continue
            c = points[k]
            if (c[1]-a[1])*(b[0]-a[0]) >= (b[1]-a[1])*(c[0]-a[0]):
                valid = False
                break
        if valid:
            break
    polygon = [a, b]
    for k in range(n-2):
        while True:
            i = random.randint(0, n-1)
            j = random.randint(0, n-1)
            if i == j:
                continue
            a, b = points[i], points[j]
            valid = True
            for p in polygon:
                if (b[0]-a[0])*(p[1]-a[1]) >= (b[1]-a[1])*(p[0]-a[0]):
                    valid = False
                    break
            if valid:
                break
        polygon.insert(polygon.index(a)+1, b)
    return polygon

# Example usage:
polygon = generate_polygon(5, 0, 10, 0, 10)
print(polygon)

这个代码使用随机数生成了 n 个点，然后按照 x 坐标排序，将前两个点作为多边形的左下角和右下角，后面的点作为多边形的上部。然后从任意两个点开始，判断其他点是否在它们的左侧，如果是，则重新选择两个点，直到找到一个合法的边。然后从这条边开始，每次选择一个点，将它插入到多边形中，直到插入 n-2 个点为止。最后返回多边形的顶点坐标列表。

写一份生成随机凹多边形的python代码

以下是一份生成随机凹多边形的 Python 代码：

import random

def generate_polygon(num_vertices):
    vertices = []
    for i in range(num_vertices):
        x = random.uniform(-1, 1)
        y = random.uniform(-1, 1)
        vertices.append((x, y))
    
    # Ensure that the polygon is concave
    while True:
        i, j, k = random.sample(range(num_vertices), 3)
        if is_concave(vertices[i], vertices[j], vertices[k]):
            vertices[i] = reflect(vertices[i], vertices[j], vertices[k])
            break
    
    return vertices

def is_concave(p1, p2, p3):
    # Check if the angle between the two vectors is greater than 180 degrees
    v1 = (p2[0] - p1[0], p2[1] - p1[1])
    v2 = (p3[0] - p2[0], p3[1] - p2[1])
    cross_product = v1[0] * v2[1] - v1[1] * v2[0]
    return cross_product < 0

def reflect(p1, p2, p3):
    # Reflect p1 across the line defined by p2 and p3
    v1 = (p2[0] - p1[0], p2[1] - p1[1])
    v2 = (p3[0] - p2[0], p3[1] - p2[1])
    dot_product = v1[0] * v2[0] + v1[1] * v2[1]
    length_squared = v2[0] ** 2 + v2[1] ** 2
    t = 2 * dot_product / length_squared
    return (p1[0] + t * v2[0], p1[1] + t * v2[1])

这个函数接受一个参数 `num_vertices`，表示生成的多边形的顶点数。它会在 $x$ 和 $y$ 轴上均匀分布的范围内随机生成这些顶点，然后使用 `is_concave` 函数检查是否是凹多边形。如果不是凹多边形，它会使用 `reflect` 函数将其中一个顶点反射到凹多边形内部。最后，它返回一个包含所有顶点的列表。