Python中Perlin噪声与Poisson圆盘采样的结合

我试图在2d网格上复制真实的植被放置。为此，我使用泊松圆盘采样（

Bridson算法

）植被布局和

perlin噪声

来确定每个区域的植被密度

当我排除柏林噪声并保持恒定的最小距离时，我会获得理想的结果。但是，当我通过柏林噪声改变最小距离时，结果没有意义

我做错了什么

Python 3.4.4。我试着从中查看psuedo代码，我甚至四处查看过。 我还从[github]（）复制了代码，并对其进行了轻微修改

但我似乎无法理解我的错误

main.py

import subprocess as sp

import matplotlib.pyplot as plt
import numpy as np
from scipy.misc import toimage


import noise

from Poisson import poisson_disc_samples


def generate_perlin_poisson(width, height):

    # Perlin Noise
    print('Perlin Noise')
    shape = (height, width)
    scale = 100.0
    octaves = 6
    persistence = 0.5
    lacunarity = 2.0

    world = np.zeros(shape)
    for i in range(shape[0]):
        for j in range(shape[1]):
            world[i][j] = noise.pnoise2(i / scale,
                                        j / scale,
                                        octaves=octaves,
                                        persistence=persistence,
                                        lacunarity=lacunarity,
                                        repeatx=shape[0],
                                        repeaty=shape[1],
                                        base=0)
    toimage(world).show()

    min_rad = 1
    max_rad = 5
    z = np.interp(world, (np.amin(world), np.amax(world)), (min_rad, max_rad))

    # # Notepad PrintOut
    # fileName = 'perlin_world.txt'
    # programName = "notepad.exe"
    # with open(fileName, 'w') as f:
    #     for row in range(z.shape[0]):
    #         # print(row, z[row])
    #         f.write(str(z[row].tolist()) + '\n')
    #
    # sp.Popen([programName, fileName])

    # Bridson Poisson Disc Sampling
    print('Bridson Poisson Disc Sampling')
    plt.scatter(*zip(*poisson_disc_samples(width=height, height=width, r_max=max_rad, r_min=min_rad, r_array=z)), c='g', alpha=0.6, lw=0)
    plt.show()

    print('Completed.')


if __name__ == '__main__':
    width, height = 256, 256
    generate_perlin_poisson(width, height)

泊松比

from random import random
from math import cos, sin, floor, sqrt, pi, ceil


def euclidean_distance(a, b):
    dx = a[0] - b[0]
    dy = a[1] - b[1]
    return sqrt(dx * dx + dy * dy)


def poisson_disc_samples(width, height, r_max, r_min, k=3, r_array=[], distance=euclidean_distance, random=random):
    tau = 2 * pi
    cellsize = r_max / sqrt(2)

    grid_width = int(ceil(width / cellsize))
    grid_height = int(ceil(height / cellsize))
    grid = [None] * (grid_width * grid_height)

    def grid_coords(p):
        return int(floor(p[0] / cellsize)), int(floor(p[1] / cellsize))

    def fits(p, gx, gy, r):
        yrange = list(range(max(gy - 2, 0), min(gy + 3, grid_height)))
        for x in range(max(gx - 2, 0), min(gx + 3, grid_width)):
            for y in yrange:
                g = grid[x + y * grid_width]
                if g is None:
                    continue

                r = r_array[int(floor(g[0]))][int(floor(g[1]))]
                if distance(p, g) <= r:  # too close
                    return False
        return True

    p = width * random(), height * random()
    queue = [p]
    grid_x, grid_y = grid_coords(p)
    grid[grid_x + grid_y * grid_width] = p

    z_max = width * height * 8
    z = 0

    while queue:
        qindex = int(random() * len(queue))  # select random point from queue
        qx, qy = queue.pop(qindex)
        r = r_array[int(floor(qx))][int(floor(qy))]
        # print('min_dist:', r)

        z += 1
        if z > z_max:
            print('max iteration exceeded')
            break

        for _ in range(k):
            alpha = tau * random()
            d = r * sqrt(3 * random() + 1)
            px = qx + d * cos(alpha)
            py = qy + d * sin(alpha)

            if not (0 <= px < width and 0 <= py < height):
                continue

            p = (px, py)
            grid_x, grid_y = grid_coords(p)
            if not fits(p, grid_x, grid_y, r):
                continue
            queue.append(p)
            grid[grid_x + grid_y * grid_width] = p
    return [p for p in grid if p is not None]

从随机导入随机
从数学导入cos、sin、floor、sqrt、pi、ceil
def欧氏距离（a，b）：
dx=a[0]-b[0]
dy=a[1]-b[1]
返回sqrt（dx*dx+dy*dy）
def poisson_disc_样本（宽度、高度、r_最大值、r_最小值、k=3、r_数组=[]，距离=欧氏距离，随机=随机）：
tau=2*pi
cellsize=r_max/sqrt（2）
网格宽度=int（单元（宽度/单元大小））
网格高度=int（单元（高度/单元大小））
网格=[None]*（网格宽度*网格高度）
def网格坐标（p）：
返回int（floor（p[0]/cellsize）），int（floor（p[1]/cellsize））
def配合（p、gx、gy、r）：
Y范围=列表（范围（最大（gy-2,0），最小（gy+3，网格高度）））
对于范围内的x（最大值（gx-2，0），最小值（gx+3，网格宽度））：
对于y范围内的y：
g=网格[x+y*网格宽度]
如果g为无：
持续
r=r_数组[int（floor（g[0]））][int（floor（g[1]））]
如果距离（p，g）z_max：
打印（'超过最大迭代次数'）
打破
对于范围（k）内的uu：
alpha=tau*random（）
d=r*sqrt（3*random（）+1）
px=qx+d*cos（α）
py=qy+d*sin（α）
如果不是（0我看到的一个问题是k=3。如果你看，他建议k=30。如果k太低，你没有进行足够的测试，以确定候选点是否接近现有点。正如你在输出中看到的那样，这很容易导致意外的聚束。另一个问题是，通用Bridson算法假定r为静态值，但聚束使用Perlin得到的结果是因为r随噪声值而变化。Bridson算法必须进行相当大的修改，因为r驱动单元大小