def __init__(self, size, seed=0, population=1000000): self.size = size self.population = population noise = generate_perlin_noise_2d(size, (4, 4), (False, False)) noise = np.where(noise < 0, 0, noise) noise *= population / np.sum(noise) self.population_distribution = noise
def _instantiate_grid_(self): self._hex_model = loader.loadModel("models/simple_hex.obj") # NOTE: higher resolution has steeper gradients per area. # The generation of terrain with perlin noise should be done elsewhere. np.random.seed(12345) self.terrain_noise = generate_perlin_noise_2d((512, 512), (32, 32), tileable=(True, True)) # Set the initial position and scale. self._hex_model.setPos(0, 0, 0) self._hex_model.setScale(1) self._hex_model.setHpr(0, 0, 0) self._hex_model.setDepthOffset(1) center_chunk = np.array((0, 0, 0)) chunk_id = self.data_model.chunk_vec_to_buf(center_chunk) starting_chunk = self.data_model.load_chunk(chunk_id) chunk_radius_to_render = 2 radius_to_render = (self.data_model.chunk_radius * 3 + 1) * chunk_radius_to_render # BFS Queue neighbors_to_explore = [starting_chunk] seen_neighbors = set() loaded_chunks = {chunk_id} while len(neighbors_to_explore) != 0: chunk = neighbors_to_explore.pop(0) if chunk in seen_neighbors: continue seen_neighbors.add(chunk) # Only render chunk if the chunk's radius is less than or equal to R away origin_d = cubic_manhattan(starting_chunk.chunk_center, chunk.chunk_center) if origin_d > radius_to_render: continue # Convert the list of neighbor positions to ids, then load the neighbors. for neighbor_vector in chunk.neighbor_chunk_vec: neighbor_id = self.data_model.chunk_vec_to_buf(neighbor_vector) if neighbor_id not in loaded_chunks: self.data_model.load_chunk(neighbor_id) loaded_chunks.add(neighbor_id) self._render_chunk(chunk) neighbors_to_explore.extend( filter( lambda n: n is not None and n not in neighbors_to_explore, chunk.neighbors))
def __init__(self, shape, res, seed=0): """ + shape: shape of the generated array (tuple of 2 ints) + res: number of periods of noise to generate along each axis (tuple of 2 ints) + seed: rng seed (numpy) Note: shape must be a multiple of res """ random.seed(seed) noise = generate_perlin_noise_2d(shape, res, (True, True)) # [-1, 1] -> [-pi, pi] # field = noise * 2 * pi field = noise super().__init__(field) self.shape = shape self.res = res
def generate_z_vect_from_perlin_noise(seed=1001, size_z=1, scale=1.0): np.random.seed(seed) x = generate_perlin_noise_2d((size_z, VECTOR_DIM), (1, 1)) x = x * scale return x
def random_image(array_shape, shapes_number, shapes_min_size=(1, 1), shapes_max_size=(None, None)): """ return an image filled with random shapes with noise and texture. to avoid using to much parameters in the function, most of them are fixed at the start of the function. """ background_noise = True shape_texture = True shape_noise = True final_noise = True fill_range = (0, 255) background_noise_mean = 128 background_noise_std = 32 texture_noise_res_min = 2 texture_noise_res_max = 16 texture_noise_amp = 42 tnrmin = texture_noise_res_min tnrmax = texture_noise_res_max shape_gaussian_noise_mean = 0 shape_gaussian_noise_std = 10 final_added_gaussian_noise_mean = 0 final_added_gaussian_noise_std = 20 # check and set shapes_max_size sms = np.asarray(array_shape) for i in range(len(shapes_max_size)): if shapes_max_size[i] is not None: sms[i] = min(shapes_max_size[i], array_shape[i]) shapes_max_size = tuple(sms) # check and set shapes_min_size sms = np.asarray(shapes_max_size) for i in range(len(shapes_min_size)): if shapes_min_size[i] is not None: sms[i] = min(shapes_min_size[i], array_shape[i]) shapes_min_size = tuple(sms) # background noise if background_noise: array = ( np.random.standard_normal(array_shape) * background_noise_std + background_noise_mean).astype(dtype) array = scipy.ndimage.gaussian_filter(array, 0.5) else: array = np.zeros(array_shape, dtype=dtype) print(array.dtype) # add random shapes for _ in range(shapes_number): # create new shape fill = randint(fill_range[0], fill_range[1]) mask = elastic_deformation( random_ellipsoid(array.shape, shapes_min_size, shapes_max_size)) # mask = (elasticdeform.deform_random_grid(random_spheroid(array.shape, shapes_max_size), sigma=4, points=3) > 0) * 1 # mask = random_shape_multi_resolution(array.shape, shapes_max_size, resolution=2, iteration=3) # mask = random_shape(array.shape, shapes_max_size, iteration=10) # skip if void shape if np.sum(mask) == 0: continue shape = np.copy(mask) if shape_texture: # add perlin / fractal noise to create texture for the shape # get mask bounding box for texture and noise x, y = np.where(mask) x_min, y_min = x.min(), y.min() x_max, y_max = x.max(), y.max() x_size, y_size = x_max - x_min, y_max - y_min # apply noise to mask noise_res_x, noise_res_y = randint(tnrmin, tnrmax), \ randint(tnrmin, tnrmax) x_size, y_size = ((x_size//noise_res_x)+1)*noise_res_x,\ ((y_size//noise_res_y)+1)*noise_res_y try: texture_noise = generate_perlin_noise_2d( (x_size, y_size), (noise_res_x, noise_res_y), tileable=(False, False)) except: print("generate_perlin_noise_2d failed, alternative used") sX, sY = randint(1, 50) / 100, randint(1, 50) / 100 rX, rY = (x_size * sX) // 2, (y_size * sY) // 2 arX, arY = np.arange(-rX - 1, rX + 1, sX), \ np.arange(-rY - 1, rY + 1, sY) xx, yy = np.meshgrid(arY, arX) texture_noise = (np.sin(xx) / 2 + np.sin(yy) / 2 + np.tanh(xx + yy) / 2) / 4 texture_noise = texture_noise[0:x_size, 0:y_size] shape_subpart = shape[x_min:x_min + x_size, y_min:y_min + y_size].shape shape[x_min:x_min+x_size, y_min:y_min+y_size] = \ np.clip(((texture_noise[0:shape_subpart[0], 0:shape_subpart[1]] * 2) * texture_noise_amp) + fill, 0, 255) else: shape = shape * fill if shape_noise: # add gaussian noise gaussian_noise = np.random.normal(shape_gaussian_noise_mean, shape_gaussian_noise_std, shape.shape) shape[mask == 1] = np.clip( shape[mask == 1] + gaussian_noise[mask == 1], 0, 255) array[mask == 1] = shape[mask == 1] if final_noise: # add gaussian noise array = np.clip( array + np.random.normal(final_added_gaussian_noise_mean, final_added_gaussian_noise_std, array.shape), 0, 255) return array, mask