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()