def __init__(self, shape, scale, octave, pers, lac, water_level):
# Inherits from the Perlin and Map classes
Perlin.__init__(self, shape, scale, octave, pers, lac)
Map.__init__(self, mode='RGB', size=shape)
# Level below which the noise value is considered water
self.waterLevel = water_level
def __init__(self, size, rand):
"""Initializer
Args:
size (int): Map size
rand (np.random.RandomState): Numpy random object
"""
self.size = size
self.rand = rand
#self.gen = OpenSimplex(seed=self.rand.randint(0, 100000))
self.gen = Perlin(self.rand.randint(0, 100000))
class NoiseTexture(Texture):
def __init__(self,sc = 1.0):
self.noise = Perlin()
self.scale = sc
def value(self,u,v,p):
#return Vec3(1.0,1.0,1.0) *0.5* (1+self.noise.turb(self.scale*p))
#return Vec3(1.0,1.0,1.0) * self.noise.turb(self.scale*p)
return Vec3(1.0,1.0,1.0) *0.5* (1+sin(self.scale * p.z + 10*self.noise.turb(p)))
class NoiseTexture(Texture):
'''Texture generated by a custom Perlin noise generator'''
def __init__(self, scale=1):
self.noise = Perlin()
self.scale = scale
def value(self, u, v, p):
return Color(1, 1, 1) * 0.5 * (
1.0 + sin(self.scale * p.z + 10 * self.noise.turb(p))
) # Marble texture using Perlin noise
def generate_trees(self, seed):
###################################
### DO NOT MODIFY THIS FUNCTION ###
###################################
trees = []
perlin = Perlin(seed)
scale = 10.0 / min(self.width, self.height)
for y in range(self.height):
row = []
for x in range(self.width):
tree_h = perlin.noise(x * scale, y * scale, 0.5)
tree_h = max(0, tree_h * 1.7 - 0.7) * 10
row.append(Tree(int(tree_h)))
trees.append(row)
# `trees` is a grid (two-dimensional list) of `Tree` objects
return trees
def gen_points():
'''
generate initial mesh points
'''
pts = np.zeros((N * N, 3))
pts[:, 0] = np.repeat(np.arange(-N / 2, N / 2), N)
pts[:, 2] = np.tile(np.arange(N) + 10, N)
p1 = Perlin(n, dt)
Y = np.array(p1.grid).ravel()
Y /= Y.max()
return pts, Y
def __main__():
p = 10
nx = 2**p
ny = 2**p
sx = 1.0
sy = 1.0
fx = sx / nx
fy = sy / ny
powers = prime_list(10, 30)
steps = 1000
rate = 0.25
levels = 4
inv_levels = 1.0 / levels
print(f"Resolution {nx} x {ny}")
print(f"powers: {powers}")
noise = []
ratios = []
for p in powers:
noise.append(Perlin(p, int(p * ny / nx)))
ratios.append(1.0 / p)
for nt in range(steps):
bar = Bar("Sampling", max=ny)
samples = np.zeros([nx, ny])
for iy in range(ny):
y = iy * fy
for ix in range(nx):
x = ix * fx
samples[ix, iy] = sample(noise, ratios, x, y)
bar.next()
bar.finish()
min = samples.min()
max = samples.max()
print("Min: ", min)
print("Max: ", max)
samples -= min
samples /= (max - min)
for iy in range(ny):
for ix in range(nx):
samples[ix, iy] = (samples[ix, iy] % inv_levels) * levels
plot(samples, nt)
for (n_map, r) in zip(noise, ratios):
n_map.evolve(r * rate)
class chopin:
tactLenght = int(0)
lastLenght = int(0)
mn = float(10000.0)
mx = float(0)
lenghts = []
P = Perlin()
previous = int(0)
Stala = float()
def __init__(self):
self.Stala = random.random()
self.tactLenght = 16
self.lastLenght = self.tactLenght
for i in range(5):
self.lenghts.append(pow(2, i))
def getSound(self):
tempLenght = int()
while (True):
tempLenght = self.lenghts[random.randrange(0, 5)]
if tempLenght <= self.lastLenght:
self.lastLenght -= tempLenght
break
if (self.lastLenght == 0):
self.lastLenght = self.tactLenght
self.previous += tempLenght
if (self.previous * self.Stala > 30):
self.previous = 0
self.Stala = random.random()
temp = self.previous * self.Stala
return sound.makeSound(tempLenght, int(self.P.getValue(0, temp) * 10))
#end of getSound method
def getMelody(self, lenght):
arr = []
for i in range(lenght):
arr.append(self.getSound())
return arr
import astar
from map import Map, MapElement, MapView
from astar import AStar
from imagecache import ImageCache
from maputils import getCost, getHeuristicCost, setCost, isImpassable
from random import random, randint
from perlin import Perlin
import sys, pygame
per = Perlin()
def initMapElement(elem):
#val = per.perlin2d(elem.x, elem.y, 0.15, 4)
val = per.perlin2d(elem.x, elem.y, 40, 4)
if int(val * 4) == 0:
i = 'impassable-1'
t = 'impassable'
else:
i = 'normal'
t = 'normal'
elem.meta = {'image': i, 'type': t}
class MapSprite(pygame.sprite.Sprite):
def __init__(self):
pygame.sprite.Sprite.__init__(self)
self.location = [0, 0]
self.mapView = None
class NoiseGenerator:
"""Noise generation class
"""
def __init__(self, size, rand):
"""Initializer
Args:
size (int): Map size
rand (np.random.RandomState): Numpy random object
"""
self.size = size
self.rand = rand
#self.gen = OpenSimplex(seed=self.rand.randint(0, 100000))
self.gen = Perlin(self.rand.randint(0, 100000))
def noise(self, nx, ny):
"""Convert [-1, 1] noise to [0,1]
Args:
nx (float): x coord
ny (float): y coord
Returns:
float: Noise value
"""
return self.gen.noise2d(nx, ny) / 2.0 + 0.5
def lake_noise(self, freq=1.0):
"""Generate Perlin noise for lakes
Args:
freq (float, optional): Frequency. Defaults to 1.0.
Returns:
list: List of lists containing noise values
"""
values = []
for y in range(self.size):
values.append([0] * self.size)
for x in range(self.size):
nx = x/self.size - 0.5
ny = y/self.size - 0.5
value = self.noise(freq*nx, freq*ny)
values[y][x] = value
return values
def ocean_noise(self, freq=1.0, dist=1.0):
"""Generate Perlin noise for ocean
Args:
freq (float, optional): Frequency. Defaults to 1.0.
dist (float, optional): Distance factor. Defaults to 1.0.
Returns:
list: List of lists containing noise values
"""
values = []
for y in range(self.size):
values.append([0] * self.size)
for x in range(self.size):
nx = x/self.size - 0.5
ny = y/self.size - 0.5
d = sqrt(nx*nx + ny*ny) / sqrt(0.5) * dist
value = self.noise(freq*nx, freq*ny)
values[y][x] = (1 + value - d) / 2
return values
def poisson_disc_samples(self, r, k=10):
""" Generate random samples for current image size using Poisson Disk sampling
Inspired by: https://github.com/emulbreh/bridson
Args:
r (float): Minimum distance between samples
k (int, optional): Number of attempts for points to be placed. Defaults to 10.
Returns:
list: List of generated samples
"""
tau = 2 * pi
cellsize = r / sqrt(2)
grid_size = int(ceil(self.size / cellsize))
grid = [None] * (grid_size * grid_size)
def grid_coords(p):
return int(floor(p[0] / cellsize)), int(floor(p[1] / cellsize))
def fits(p, gx, gy):
yrange = list(range(max(gy - 2, 0), min(gy + 3, grid_size)))
for x in range(max(gx - 2, 0), min(gx + 3, grid_size)):
for y in yrange:
g = grid[x + y * grid_size]
if g is None:
continue
if dist(p, g) <= r:
return False
return True
p = int(self.size * self.rand.rand()), int(self.size * self.rand.rand())
queue = [p]
grid_x, grid_y = grid_coords(p)
grid[grid_x + grid_y * grid_size] = p
while queue:
qi = int(self.rand.rand() * len(queue))
qx, qy = queue[qi]
queue[qi] = queue[-1]
queue.pop()
for _ in range(k):
alpha = tau * self.rand.rand()
d = r * sqrt(3 * self.rand.rand() + 1)
px = int(qx + d * cos(alpha))
py = int(qy + d * sin(alpha))
if not (0 <= px < self.size and 0 <= py < self.size):
continue
p = (px, py)
grid_x, grid_y = grid_coords(p)
if not fits(p, grid_x, grid_y):
continue
queue.append(p)
grid[grid_x + grid_y * grid_size] = p
return [p for p in grid if p is not None]
def __init__(self,sc = 1.0): self.noise = Perlin() self.scale = sc
def __init__(self, shape, scale, octave, pers, lac):
# Inherits from the Perlin and Map classes
Perlin.__init__(self, shape, scale, octave, pers, lac)
Map.__init__(self, mode='1', size=shape)
from perlin import Perlin
from PIL import Image
image = Image.new("RGB", (300, 300), "white")
pixels = image.load()
p = Perlin()
mn = 10000
mx = -10000
i = 0
j = 0.0
while (i <= 3):
j = 0
while (j <= 3):
temp = p.getValue(i, j)
temp *= 255
temp = int(temp)
pixels[100 * i, 100 * j] = (temp, temp, temp)
mn = min(mn, temp)
mx = max(mx, temp)
j += 0.01
i += 0.01
print(mn, mx)
image.show()