Сочетание Perlin Noise и Poisson Disc Sampling в Python

Question

Я пытаюсь воспроизвести реалистичное размещение растительности на двумерной сетке. Для этого я использую выборку растительности для отбора проб пуассоновых дисков (Bridson algorithm) и perlin noise для определения плотности растительности на площадь.

Когда я исключаю perlin noise и держу постоянное минимальное расстояние, я получаю желаемые результаты. Однако, когда я изменяю минимальное расстояние с помощью perlin noise, результаты не имеют смысла.

Что я делаю неправильно?

Python 3.4.4. Я попытался посмотреть псевдо-код из здесь , я посмотрел вокруг StackOverflow , даже здесь . Я также скопировал код из [github] (https://github.com/emulbreh/bridson) и немного его изменил.

Но я не могу понять свою ошибку.

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)

Poisson.py

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]

Я ожидал таких результатов:

, где я могу почти визуализировать карту шума Перлина. Кстати, это от 1-й ссылки вверху.

Но я получаю вывод, подобный этому:

Карта оттенков серого - это связанный с этим перлин-шум.

Я знаю, что есть более эффективные способы ведения дел. Однако я планирую придерживаться Python.