Voronoi图最容易实现的算法？[关闭]

实现Voronoi图的简单算法是什么？

我找不到伪形式的任何算法。请分享一些Voronoi图算法，教程等链接。

一种简单的算法来计算点集的Delaunay三角剖分是翻转边缘。由于Delaunay三角剖分是Voronoi图的对偶图，因此您可以根据线性时间的三角剖分构造图。

不幸的是，翻转方法的最坏情况运行时间是O（n ^ 2）。存在更好的算法，例如Fortune的行扫描，这需要O（n log n）时间。不过，要实现它有些棘手。如果您很懒（就像我一样），我建议您寻找Delaunay三角剖分的现有实现，使用它，然后计算对偶图。

通常，关于这一主题的一本好书是de Berg等人的《计算几何》。

最简单？那是蛮力方法：对于输出中的每个像素，遍历所有点，计算距离，并使用最接近的像素。可以慢，但是很简单。如果性能不重要，那就可以了。我本人一直在进行有趣的改进，但仍在寻找是否其他人有相同（相当明显）的想法。

Bowyer-Watson算法非常容易理解。这是一个实现：http : //paulbourke.net/papers/triangulate/。这是一组点的delaunay三角剖分，但是您可以使用它来获取delaunay的对偶，即伏洛诺伊图。顺便说一句。最小生成树是Delaunay三角剖分的子集。

构造voronoi图的最有效的算法是Fortune算法。它以O（n log n）运行。

这是他在C中的参考实现的链接。

我个人非常喜欢Bill Simons和Carson Farmer的python实现，因为我发现它更易于扩展。

Wikipedia页面（http://en.wikipedia.org/wiki/Voronoi_diagram）的“算法”部分包含用于实现Voronoi图的算法的链接。

Stephan Fortune / Shane O'Sullivan可在C和C ++中免费使用voronoi实现二维图形：

VoronoiDiagramGenerator.cpp 

VoronoiDiagramGenerator.h 

您会在许多地方找到它。即位于http://www.skynet.ie/~sos/masters/

这是一个使用quat-tree并允许增量构造的javascript实现。

http://code.google.com/p/javascript-voronoi/

当最初的问题询问如何实施Voronoi时，如果我在搜索有关此主题的信息时找到了一条说以下内容的帖子，那会节省很多时间：

互联网上有很多“几乎正确的” C ++代码可用于实现Voronoi图。当种子点变得非常密集时，大多数都很少触发故障。我建议您在预期的完成项目中使用的点数进行广泛的在线测试，以免浪费太多时间。

我在网上发现的最好的实现是从此处链接的MapManager程序的一部分：http : //www.skynet.ie/~sos/mapviewer/voronoi.php 它通常可以工作，但是在处理时我会出现间歇性的图表损坏订购10 ^ 6分。我还无法弄清楚腐败如何蔓延。

昨晚我发现了这一点：http : //www.boost.org/doc/libs/1_53_0_beta1/libs/polygon/doc/voronoi_main.htm “ The Boost.Polygon Voronoi库”。看起来很有希望。它带有基准测试，以证明其准确性和出色的性能。该库具有适当的接口和文档。我很惊讶以前没有找到这个库，因此我在这里写了。（我在研究初期就读了这篇文章。）

实际上，https：//rosettacode.org/wiki/Voronoi_diagram上提供了25种不同语言的实现。

例如，对于Java：

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Ellipse2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Random;

import javax.imageio.ImageIO;
import javax.swing.JFrame;

public class Voronoi extends JFrame {
    static double p = 3;
    static BufferedImage I;
    static int px[], py[], color[], cells = 100, size = 1000;

    public Voronoi() {
        super("Voronoi Diagram");
        setBounds(0, 0, size, size);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        int n = 0;
        Random rand = new Random();
        I = new BufferedImage(size, size, BufferedImage.TYPE_INT_RGB);
        px = new int[cells];
        py = new int[cells];
        color = new int[cells];
        for (int i = 0; i < cells; i++) {
            px[i] = rand.nextInt(size);
            py[i] = rand.nextInt(size);
            color[i] = rand.nextInt(16777215);

        }
        for (int x = 0; x < size; x++) {
            for (int y = 0; y < size; y++) {
                n = 0;
                for (byte i = 0; i < cells; i++) {
                    if (distance(px[i], x, py[i], y) < distance(px[n], x, py[n], y)) {
                        n = i;

                    }
                }
                I.setRGB(x, y, color[n]);

            }
        }

        Graphics2D g = I.createGraphics();
        g.setColor(Color.BLACK);
        for (int i = 0; i < cells; i++) {
            g.fill(new Ellipse2D .Double(px[i] - 2.5, py[i] - 2.5, 5, 5));
        }

        try {
            ImageIO.write(I, "png", new File("voronoi.png"));
        } catch (IOException e) {

        }

    }

    public void paint(Graphics g) {
        g.drawImage(I, 0, 0, this);
    }

    static double distance(int x1, int x2, int y1, int y2) {
        double d;
        d = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); // Euclidian
    //  d = Math.abs(x1 - x2) + Math.abs(y1 - y2); // Manhattan
    //  d = Math.pow(Math.pow(Math.abs(x1 - x2), p) + Math.pow(Math.abs(y1 - y2), p), (1 / p)); // Minkovski
        return d;
    }

    public static void main(String[] args) {
        new Voronoi().setVisible(true);
    }
}

最简单的算法来自于voronoi图的定义：“将具有n个点的平面划分为凸多边形，这样每个多边形恰好包含一个生成点，并且给定多边形中的每个点都比它的生成点更接近生成点。从钨“的定义。

这里的重要部分是每个点都比其他点更靠近生成点，从这里开始，算法非常简单：

1. 有一系列的生成点。
2. 遍历画布上的每个像素。
3. 对于每个像素，寻找与其最接近的生成点。
4. 根据您希望使像素变色的图表。如果要用边界分隔图，请检查第二个最接近的点，然后检查它们的差异和颜色，如果边界值小于某个值，则使用边界色。

如果要使用颜色图，则需要为每个生成点关联一个颜色，并为每个像素为其最接近的生成点关联颜色。就是这样，它效率不高，但很容易实现。

这是最快的方法-这是一个简单的voronoi，但看起来不错。它将空间划分为一个网格，在每个随机放置的网格单元中放置一个点，然后沿着网格移动并检查3x3单元，以查找其与相邻单元的关系。

没有渐变，速度更快。

您可能会问最简单的3d voronoi是什么。知道会很有趣。大概是3x3x3的单元格并检查了梯度。

http://www.iquilezles.org/www/articles/smoothvoronoi/smoothvoronoi.htm

float voronoi( in vec2 x )
{
    ivec2 p = floor( x );
    vec2  f = fract( x );

    float res = 8.0;
    for( int j=-1; j<=1; j++ )
    for( int i=-1; i<=1; i++ )
    {
        ivec2 b = ivec2( i, j );
        vec2  r = vec2( b ) - f + random2f( p + b );
        float d = dot( r, r );

        res = min( res, d );
    }
    return sqrt( res );
}

这与契比雪夫距离相同。您可以从此处使用random2f 2d浮点噪声：

https://www.shadertoy.com/view/Msl3DM

编辑：我已经将其转换为C类似代码

这是前一阵子，为了那些人的利益，我认为这很酷：

 function rndng ( n: float ): float
 {//random number -1, 1
     var e = ( n *321.9)%1;
     return  (e*e*111.0)%2-1;
 }

 function voronoi(  vtx: Vector3  )
 {
     var px = Mathf.Floor( vtx.x );
     var pz = Mathf.Floor( vtx.z );
     var fx = Mathf.Abs(vtx.x%1);
     var fz = Mathf.Abs(vtx.z%1);

     var res = 8.0;
     for( var j=-1; j<=1; j++ )
     for( var i=-1; i<=1; i++ )
     {
         var rx = i - fx + nz2d(px+i ,pz + j ) ;
         var rz = j - fz + nz2d(px+i ,pz + j ) ;
         var d = Vector2.Dot(Vector2(rx,rz),Vector2(rx,rz));
         res = Mathf.Min( res, d );
     }
     return Mathf.Sqrt( res );
 }

请检查Richard Franks在问题上的答案中使用伪代码提出的蛮力解决方案，该问题在给定点集和Delaunay三角剖分的情况下如何得出Voronoi图？

基于Fortune算法/扫行算法在Google代码上找到了这个出色的C＃库

https://code.google.com/p/fortune-voronoi/

您只需要创建一个列表。可以通过传入两个数字（坐标）作为浮点数来创建向量。然后将列表传递到Fortune.ComputeVoronoiGraph（）

您可以从以下维基百科页面上进一步了解算法的概念：

http://en.wikipedia.org/wiki/Fortune%27s_algorithm

http://en.wikipedia.org/wiki/Sweep_line_algorithm

虽然我无法理解的一件事是如何为部分无限的边创建一条线（对坐标几何不是很了解：-）。如果有人知道，也请让我知道。

如果尝试将其绘制到图像上，则可以使用基于队列的泛洪填充算法。

Voronoi::draw(){
    // define colors for each point in the diagram;
    // make a structure to hold {pixelCoords,sourcePoint} queue objects
    // initialize a struct of two closest points for each pixel on the map
    // initialize an empty queue;

    // for each point in diagram:
        // for the push object, first set the pixelCoords to pixel coordinates of point;
        // set the sourcePoint of the push object to the current point;
        // push the queue object;

    // while queue is not empty:
        // dequeue a queue object;
        // step through cardinal neighbors n,s,e,w:
            // if the current dequeued source point is closer to the neighboring pixel than either of the two closest:
                // set a boolean doSortAndPush to false;
                // if only one close neighbor is set:
                    // add sourcePoint to closestNeighbors for pixel;
                    // set doSortAndPush to true;
                // elif sourcePoint is closer to pixel than it's current close neighbor points:
                    // replace the furthest neighbor point with sourcePoint;
                    // set doSortAndPush to true;
                // if flag doSortAndPush is true:
                    // re-sort closest neighbors; 
                    // enqueue object made of neighbor pixel coordinates and sourcePoint;

    // for each pixel location:
        // if distance to closest point within a radius for point drawing:
            // color pixel the point color;
        // elif distances to the two closest neighbors are roughly equal:
            // color the pixel to your border color;
        // else 
            // color the pixel the color of the point's region; 

}

使用队列将确保区域并行分布，从而最大程度地减少了像素访问的总数。如果使用堆栈，则第一个点将填充整个图像，然后第二个点将填充比第一个点更近的像素。这将继续下去，大大增加访问量。使用FIFO队列按推入像素的顺序处理像素。无论使用堆栈还是队列，生成的图像将大致相同，但是用于队列的big-O远比堆栈算法的big-O更接近线性（相对于图像像素数）。一般的想法是，区域将以相同的速度扩散，并且碰撞通常将恰好发生在与区域边界相对应的点上。