我有一些点(例如，信号塔位置的纬度、经度对)，我需要获取它们形成的 Voronoi 单元的多边形。

from scipy.spatial import Voronoi

tower = [[ 24.686 ,  46.7081],
       [ 24.686 ,  46.7081],
       [ 24.686 ,  46.7081]]

c = Voronoi(towers)

现在，我需要获取每个单元格的经纬度坐标中的多边形边界(以及该多边形围绕的质心)。我也需要这个 Voronoi 有界。这意味着边界不会无限延伸，而是在边界框内。

最佳答案

给定一个矩形边界框，我的第一个想法是在这个边界框和 scipy.spatial.Voronoi 生成的 Voronoï 图之间定义一种交集操作。 .一个想法不一定很好，因为这需要编写大量计算几何的基本函数。

但是，这是我想到的第二个想法(hack？):计算平面中一组 n 点的 Voronoï 图的算法的时间复杂度为 O(n ln(n))。如何添加点以将初始点的 Voronoï 单元约束在边界框中？

有界 Voronoï 图的解

一张图胜过一场精彩的演讲:

我在这里做了什么？这很简单!初始点(蓝色)位于 [0.0, 1.0] x [0.0, 1.0] 中。然后我根据 x = 0.0 通过反射对称性得到左侧的点(蓝色)(即 [-1.0, 0.0] x [0.0, 1.0]) (边界框的左边缘)。根据 x = 1.0、y = 0.0 和 y = 1.0(边界框的其他边)的反射对称性，我得到了所有点(蓝色)我需要完成这项工作。

然后我运行 scipy.spatial.Voronoi。上图描绘了生成的 Voronoï 图(我使用 scipy.spatial.voronoi_plot_2d )。

接下来要做什么？只需根据边界框过滤点、边或面。并根据众所周知的公式得到每个人脸的质心来计算centroid of polygon .这是结果的图像(质心为红色):

展示代码前的一些乐趣

太棒了!它似乎工作。如果在一次迭代后我尝试在质心(红色)而不是初始点(蓝色)上重新运行算法怎么办？如果我一次又一次地尝试呢？

第 2 步

第 10 步

第 25 步

太棒了! Voronoï 细胞倾向于最小化它们的能量...

这是代码

import matplotlib.pyplot as pl
import numpy as np
import scipy as sp
import scipy.spatial
import sys

eps = sys.float_info.epsilon

n_towers = 100
towers = np.random.rand(n_towers, 2)
bounding_box = np.array([0., 1., 0., 1.]) # [x_min, x_max, y_min, y_max]

def in_box(towers, bounding_box):
    return np.logical_and(np.logical_and(bounding_box[0] <= towers[:, 0],
                                         towers[:, 0] <= bounding_box[1]),
                          np.logical_and(bounding_box[2] <= towers[:, 1],
                                         towers[:, 1] <= bounding_box[3]))


def voronoi(towers, bounding_box):
    # Select towers inside the bounding box
    i = in_box(towers, bounding_box)
    # Mirror points
    points_center = towers[i, :]
    points_left = np.copy(points_center)
    points_left[:, 0] = bounding_box[0] - (points_left[:, 0] - bounding_box[0])
    points_right = np.copy(points_center)
    points_right[:, 0] = bounding_box[1] + (bounding_box[1] - points_right[:, 0])
    points_down = np.copy(points_center)
    points_down[:, 1] = bounding_box[2] - (points_down[:, 1] - bounding_box[2])
    points_up = np.copy(points_center)
    points_up[:, 1] = bounding_box[3] + (bounding_box[3] - points_up[:, 1])
    points = np.append(points_center,
                       np.append(np.append(points_left,
                                           points_right,
                                           axis=0),
                                 np.append(points_down,
                                           points_up,
                                           axis=0),
                                 axis=0),
                       axis=0)
    # Compute Voronoi
    vor = sp.spatial.Voronoi(points)
    # Filter regions
    regions = []
    for region in vor.regions:
        flag = True
        for index in region:
            if index == -1:
                flag = False
                break
            else:
                x = vor.vertices[index, 0]
                y = vor.vertices[index, 1]
                if not(bounding_box[0] - eps <= x and x <= bounding_box[1] + eps and
                       bounding_box[2] - eps <= y and y <= bounding_box[3] + eps):
                    flag = False
                    break
        if region != [] and flag:
            regions.append(region)
    vor.filtered_points = points_center
    vor.filtered_regions = regions
    return vor

def centroid_region(vertices):
    # Polygon's signed area
    A = 0
    # Centroid's x
    C_x = 0
    # Centroid's y
    C_y = 0
    for i in range(0, len(vertices) - 1):
        s = (vertices[i, 0] * vertices[i + 1, 1] - vertices[i + 1, 0] * vertices[i, 1])
        A = A + s
        C_x = C_x + (vertices[i, 0] + vertices[i + 1, 0]) * s
        C_y = C_y + (vertices[i, 1] + vertices[i + 1, 1]) * s
    A = 0.5 * A
    C_x = (1.0 / (6.0 * A)) * C_x
    C_y = (1.0 / (6.0 * A)) * C_y
    return np.array([[C_x, C_y]])

vor = voronoi(towers, bounding_box)

fig = pl.figure()
ax = fig.gca()
# Plot initial points
ax.plot(vor.filtered_points[:, 0], vor.filtered_points[:, 1], 'b.')
# Plot ridges points
for region in vor.filtered_regions:
    vertices = vor.vertices[region, :]
    ax.plot(vertices[:, 0], vertices[:, 1], 'go')
# Plot ridges
for region in vor.filtered_regions:
    vertices = vor.vertices[region + [region[0]], :]
    ax.plot(vertices[:, 0], vertices[:, 1], 'k-')
# Compute and plot centroids
centroids = []
for region in vor.filtered_regions:
    vertices = vor.vertices[region + [region[0]], :]
    centroid = centroid_region(vertices)
    centroids.append(list(centroid[0, :]))
    ax.plot(centroid[:, 0], centroid[:, 1], 'r.')

ax.set_xlim([-0.1, 1.1])
ax.set_ylim([-0.1, 1.1])
pl.savefig("bounded_voronoi.png")

sp.spatial.voronoi_plot_2d(vor)
pl.savefig("voronoi.png")

关于python - 从 Voronoi 单元获取有界多边形坐标，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/28665491/