def main():
simplex = OpenSimplex()
print("Generating 2D image...")
im = Image.new("L", (WIDTH, HEIGHT))
for y in range(0, HEIGHT):
for x in range(0, WIDTH):
value = simplex.noise2d(x / FEATURE_SIZE, y / FEATURE_SIZE)
color = int((value + 1) * 128)
im.putpixel((x, y), color)
im.save("noise2d.png")
print("Generating 2D slice of 3D...")
im = Image.new("L", (WIDTH, HEIGHT))
for y in range(0, HEIGHT):
for x in range(0, WIDTH):
value = simplex.noise3d(x / FEATURE_SIZE, y / FEATURE_SIZE, 0.0)
color = int((value + 1) * 128)
im.putpixel((x, y), color)
im.save("noise3d.png")
print("Generating 2D slice of 4D...")
im = Image.new("L", (WIDTH, HEIGHT))
for y in range(0, HEIGHT):
for x in range(0, WIDTH):
value = simplex.noise4d(x / FEATURE_SIZE, y / FEATURE_SIZE, 0.0, 0.0)
color = int((value + 1) * 128)
im.putpixel((x, y), color)
im.save("noise4d.png")
class Benchmark:
def __init__(self):
self.simplex = OpenSimplex(seed=0)
def run(self, number=100000):
for i in _range(number):
self.simplex.noise2d(0.1, 0.1)
self.simplex.noise3d(0.1, 0.1, 0.1)
self.simplex.noise4d(0.1, 0.1, 0.1, 0.1)
class Game(object):
def __init__(self):
self.gen = OpenSimplex(random.randint(0, sys.maxint))
def noise(self, nx, ny):
return self.gen.noise2d(nx, ny) / 2.0 + 0.5
def create_height_map(self, width, height):
fwidth = float(width)
fheight = float(height)
result = array.array('B')
for y in xrange(height):
for x in xrange(width):
nx = x / fwidth - 0.5
ny = y / fheight - 0.5
value = self.noise(10 * nx, 10 * ny)
result.append(int(255 * value if value != 1.0 else 255))
return result
append_face(f"usemtl {block}\nf {i1} {i2} {i7} {i4}")
append_face(f"f {i1} {i2} {i5} {i3}")
append_face(f"f {i4} {i7} {i8} {i6}")
append_face(f"f {i1} {i4} {i6} {i3}")
append_face(f"f {i2} {i5} {i8} {i7}")
append_face(f"f {i3} {i5} {i8} {i6}")
num_blocks+=1
file.write("\n".join([f"v {p[0]} {p[1]} {p[2]}" for p in points.values()]) + "\n" + "\n".join(faces.values()) + "\n")
print(num_blocks)
with open("test.obj", "w+") as f:
seed = 1281134870109837483
randomness = Random(seed)
noise = OpenSimplex(seed=seed)
chunks = {}
radius = 1 if len(sys.argv) < 2 else int(sys.argv[1])
print(f"Generating {(radius*2)**2} chunks...")
start = pf()
for x in range(-radius, radius):
for z in range(-radius, radius):
chunks[x, z] = noisy_chunk(noise, randomness, x, z)
print(f"Done generating chunks. ({(pf() - start):02.02f} seconds for {len(chunks)} chunks)")
# print("Adding ore pockets...")
# start = pf()
def main():
global SEALEVEL
global FEATURE_SIZE
global WATER_LEVEL
global SIZE
global pathx
global pathz
MIN = 500
MAX = 0
CNT = 0
TOT = 0
pathx = []
pathz = []
if (len(sys.argv) > 1):
if (sys.argv[1]):
SIZE = int(sys.argv[1])
else:
SIZE = 1000
if (sys.argv[2]):
SEED = int(sys.argv[2])
else:
SEED = 0
if (sys.argv[3]):
WATER_LEVEL = float(sys.argv[3])
else:
WATER_LEVEL = 15.0
if (sys.argv[4]):
FEATURE_SIZE = float(sys.argv[4])
else:
FEATURE_SIZE = 24.0
else:
SIZE = 1000
SEED = 0
WATER_LEVEL = 15.0
FEATURE_SIZE = 24.0
print("Generating world of size " + str(SIZE) + " by " + str(SIZE) + "...")
print("Seed " + str(SEED) + " Water Percentage " + str(WATER_LEVEL) +
" Land Feature Variant " + str(FEATURE_SIZE) + ".")
global MAXX
MAXX = SIZE
global MAXZ
MAXZ = SIZE
global Y
Y = [[0 for x in range(MAXX)] for z in range(MAXZ)]
global MOVE_NW
MOVE_NW = [[0 for x in range(MAXX)] for z in range(MAXZ)]
global MOVE_N
MOVE_N = [[0 for x in range(MAXX)] for z in range(MAXZ)]
global MOVE_NE
MOVE_NE = [[0 for x in range(MAXX)] for z in range(MAXZ)]
global MOVE_E
MOVE_E = [[0 for x in range(MAXX)] for z in range(MAXZ)]
global MOVE_SE
MOVE_SE = [[0 for x in range(MAXX)] for z in range(MAXZ)]
global MOVE_S
MOVE_S = [[0 for x in range(MAXX)] for z in range(MAXZ)]
global MOVE_SW
MOVE_SW = [[0 for x in range(MAXX)] for z in range(MAXZ)]
global MOVE_W
MOVE_W = [[0 for x in range(MAXX)] for z in range(MAXZ)]
global SEEDS
SEEDS = [[random.randint(0, SIZE) for x in range(MAXX)]
for z in range(MAXZ)]
simplex = OpenSimplex(seed=SEED)
for z in range(0, MAXX):
for x in range(0, MAXZ):
value = simplex.noise3d(x / FEATURE_SIZE, z / FEATURE_SIZE, 0.0)
y = int((value + 1) * 128)
if (y > MAX):
MAX = y
if (y < MIN):
MIN = y
Y[x][z] = y
SEALEVEL = int((MAX - MIN) * (WATER_LEVEL / 100)) + MIN
print("Make water level " + str(SEALEVEL) + " or below..")
# waterify W by displaying everything below SEALEVEL+1 as ~
# calculate movement costs in all direction for W but only above SEALEVEL
for Z in range(MAXZ):
for X in range(MAXX):
if (Y[X][Z] > SEALEVEL):
# process movement
# MOVE_NW[X][Z] = calmove(X,Z,1)
# MOVE_N[X][Z] = calmove(X,Z,2)
# MOVE_NE[X][Z] = calmove(X,Z,3)
# MOVE_E[X][Z] = calmove(X,,Z,4)
# MOVE_SE[X][Z] = calmove(X,Z,5)
# MOVE_S[X][Z] = calmove(X,Z,6)
# MOVE_SW[X][Z] = calmove(X,Z,7)
# MOVE_W[X][Z] = calmove(X,Z,8)
# special cases, corners and X=MAXX, Z=MAXZ
if (X == 0):
# process N, NE, E, SE, S
if (Z == 0):
# process E, SE, S
MOVE_NW[X][Z] = MOVE_N[X][Z] = MOVE_NE[X][Z] = MOVE_W[
X][Z] = MOVE_SW[X][Z] = False
MOVE_E[X][Z] = calmove(X, Z, 4)
MOVE_SE[X][Z] = calmove(X, Z, 5)
MOVE_S[X][Z] = calmove(X, Z, 6)
continue
if (Z == MAXZ):
# BOTTOM LEFT CORNER, no process S, SW, W
MOVE_W[X][Z] = MOVE_NW[X][Z] = MOVE_SE[X][Z] = MOVE_S[
X][Z] = MOVE_SW[X][Z] = False
MOVE_NE[X][Z] = calmove(X, Z, 3)
MOVE_N[X][Z] = calmove(X, Z, 2)
MOVE_E[X][Z] = calmove(X, Z, 4)
continue
# X is 0 moving down left edge of world, no NW, SW, W
MOVE_NW[X][Z] = False
MOVE_N[X][Z] = calmove(X, Z, 2)
MOVE_NE[X][Z] = calmove(X, Z, 3)
MOVE_E[X][Z] = calmove(X, Z, 4)
MOVE_SE[X][Z] = calmove(X, Z, 5)
MOVE_S[X][Z] = calmove(X, Z, 6)
MOVE_SW[X][Z] = MOVE_W[X][Z] = False
if (X == MAXX):
if (Z == 0):
# TOP RIGHT CORNER, no NW, N, NE, E, SE
MOVE_NW[X][Z] = MOVE_N[X][Z] = MOVE_NE[X][Z] = MOVE_E[
X][Z] = MOVE_SE[X][Z] = False
MOVE_S[X][Z] = calmove(X, Z, 6)
MOVE_SW[X][Z] = calmove(X, Z, 7)
MOVE_W[X][Z] = calmove(X, Z, 8)
continue
if (Z == MAXZ):
# BOTTOM RIGHT CORNER, no NE, E, SE, S, SW
MOVE_NW[X][Z] = calmove(X, Z, 1)
MOVE_N[X][Z] = calmove(X, Z, 2)
MOVE_NE[X][Z] = MOVE_E[X][Z] = MOVE_SE[X][Z] = MOVE_S[
X][Z] = MOVE_SW[X][Z] = False
MOVE_W[X][Z] = calmove(X, Z, 8)
continue
# X is MAXX moving down right edge of world, no NE, E, SE
MOVE_NW[X][Z] = calmove(X, Z, 1)
MOVE_N[X][Z] = calmove(X, Z, 2)
MOVE_NE[X][Z] = MOVE_E[X][Z] = MOVE_SE[X][Z] = False
MOVE_S[X][Z] = calmove(X, Z, 6)
MOVE_SW[X][Z] = calmove(X, Z, 7)
MOVE_W[X][Z] = calmove(X, Z, 8)
continue
if (Z == 0):
# moving across the top, no NW, N, NE
MOVE_NW[X][Z] = MOVE_N[X][Z] = MOVE_NE[X][Z] = False
MOVE_E[X][Z] = calmove(X, Z, 4)
MOVE_SE[X][Z] = calmove(X, Z, 5)
MOVE_S[X][Z] = calmove(X, Z, 6)
MOVE_SW[X][Z] = calmove(X, Z, 7)
MOVE_W[X][Z] = calmove(X, Z, 8)
continue
if (Z == MAXZ):
# moving across the bottom, no SE, S, SW
MOVE_NW[X][Z] = calmove(X, Z, 1)
MOVE_N[X][Z] = calmove(X, Z, 2)
MOVE_NE[X][Z] = calmove(X, Z, 3)
MOVE_E[X][Z] = calmove(X, Z, 4)
MOVE_SE[X][Z] = MOVE_S[X][Z] = MOVE_SW[X][Z] = False
MOVE_W[X][Z] = calmove(X, Z, 8)
continue
# Special cases done, not near an edge
MOVE_NW[X][Z] = calmove(X, Z, 1)
MOVE_N[X][Z] = calmove(X, Z, 2)
MOVE_NE[X][Z] = calmove(X, Z, 3)
MOVE_E[X][Z] = calmove(X, Z, 4)
MOVE_SE[X][Z] = calmove(X, Z, 5)
MOVE_S[X][Z] = calmove(X, Z, 6)
MOVE_SW[X][Z] = calmove(X, Z, 7)
MOVE_W[X][Z] = calmove(X, Z, 8)
addrivers(SEED)
print('Generated. Normalizing...')
# normalize W
for Z in range(MAXZ):
for X in range(MAXX):
Y[X][Z] = normalize_around(X, Z)
V = Y[X][Z]
if (MIN > V):
MIN = V
if (MAX < V):
MAX = V
CNT = CNT + 1
TOT = TOT + V
AVG = TOT / CNT
print("Normalize results: MAX " + str(MAX) + " MIN " + str(MIN) + " CNT " +
str(CNT) + " AVG " + str(AVG))
display_cell(84, 73, SEALEVEL)
print("Creating map representations:")
print("PGM world.pgm [", end='')
createfilepgm("data/world.pgm", MAX)
print("DONE]")
print("PPM world.ppm [", end='')
createfileppm("data/world.ppm")
print("DONE]")
print("TEXT world.txt [", end='')
createfiletext("data/world.txt")
print("DONE]")
print("Saving generated world to files.")
write_Y()
write_D()
write_M()
def __init__(self):
self.simplex = OpenSimplex(seed=0)
bot = bot + interp_lights((0, 8.5, 31.75), (0, 27.5, 51.75), 38)
# Right top
rt = [(8-x, y, z) for x, y, z in lt]
lightmap = lt+bot+rt
min_x = min(x for x,y,z in lightmap)
min_y = min(y for x,y,z in lightmap)
min_z = min(z for x,y,z in lightmap)
lightmap = [(x-min_x, y-min_y, z-min_z) for x,y,z in lightmap] # re-origin on extreme
max_x = max(x for x,y,z in lightmap)
max_y = max(y for x,y,z in lightmap)
max_z = max(z for x,y,z in lightmap)
simplex_a = OpenSimplex(seed=0)
simplex_b = OpenSimplex(seed=1)
simplex_c = OpenSimplex(seed=2)
simplex_scale_x = 0.02
simplex_scale_y = 0.02
simplex_scale_z = 0.02
def simplex_hsl_as_rgb(x, y, z, w):
x = x * simplex_scale_x
y = y * simplex_scale_y
z = z * simplex_scale_z
h = (simplex_a.noise4d(x, y, z, w)+1)*360
s = 100-(simplex_b.noise4d(x, y, z, w)+1)*5
l = 50+(simplex_c.noise4d(x, y, z, w))*5
r, g, b = hsluv.hsluv_to_rgb([h, s, l])
return (r*256, g*256, b*256)
def run(args):
img = cv2.imread(args.img)
img = cv2.resize(img, (800, 600), cv2.INTER_AREA)
## create a flow field
H, W = img.shape[:2]
x_noise = OpenSimplex(240)
y_noise = OpenSimplex(32)
field = np.zeros((H, W, 2))
for y in range(H):
for x in range(W):
mult = 0.0015
x_val = x_noise.noise2d(x=mult * x, y=mult * y)
y_val = y_noise.noise2d(x=mult * x, y=mult * y)
field[y, x, :] = (x_val, y_val)
# draw_field(field, N_particles=2000)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY).astype(np.float64) / 256
sigma = 3
gray = cv2.GaussianBlur(gray, ksize=(0, 0), sigmaX=sigma)
# cv2.imshow("cv: gray", gray)
# c = cv2.waitKey(0)
# if c == ord('q'):
# import sys
# sys.exit(1)
points = draw_field(field, guide=1 - gray, N_particles=10000)
# ## draw the image with the flow field
# cv2.namedWindow('cv: img', cv2.WINDOW_NORMAL)
# cv2.imshow("cv: img", img)
# # cv2.imshow("cv: field", np.linalg.norm(field, axis=2))
# cv2.imshow("cv: field", field[..., 0])
# cv2.resizeWindow('cv: img', 800, 600)
# c = cv2.waitKey(0)
# if c == ord('q'):
# import sys
# sys.exit(1)
x_margin_mm = 10
y_margin_mm = 10
H = 210 # A4
W = 297 # A4
to_draw = resize_and_center(points, H, W, x_margin_mm, x_margin_mm,
y_margin_mm, y_margin_mm)
vis_drawing(to_draw, 'r-', linewidth=0.5)
to_draw = optimize(to_draw, line_simplification_threshold=0.1)
vis_drawing(to_draw, 'k-', linewidth=0.5)
plt.plot([0, W, W, 0, 0], [0, 0, H, H, 0], 'k:')
plt.axis('equal')
plt.gca().invert_yaxis()
plt.show()
H = 210 # A4
W = 297 # A4
with Plotter('/dev/ttyUSB0', 115200) as p:
p.load_config('config.json')
p.set_input_limits((0, 0), (W, 0), (0, H), (W, H))
p.draw_polylines(to_draw)
return 0
def __init__(self, seed, diameter):
self.tmp = OpenSimplex(seed)
self.d = diameter
self.x = 0
self.y = 0
import pygame as pg
import sys
import numpy as np
import noise as no
from opensimplex import OpenSimplex
scale = 30.
seed = np.random.randint(0, 10000)
print(seed)
tmp = OpenSimplex(seed)
dim = [256, 256]
sdf = pg.display.set_mode(dim)
def tri(a):
a = (a + 1) / 2
# a=1-a*(1-a)
a = int(256 * a)
return [a, a, a]
def noi(b, k):
# a= int(128*(pnoise3(i,j,k)+1))
# return tri(tmp.noise3d(x, y, k))
return np.array([
np.array([tri(tmp.noise2d(i, j)) for j in b], dtype=np.uint8)
for i in b
],
dtype=np.uint8)
import numpy as np
from opensimplex import OpenSimplex
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import io
import imageio
def plot_arrow(x, y, dir):
plt.plot([x, x + np.cos(dir)], [y, y + np.sin(dir)], c='b')
simp = OpenSimplex()
n = 512
D_MAX = 2
T_MAX = 2 * np.pi
NUM_FRAMES = 150
x = np.linspace(0, D_MAX, n)
y = np.linspace(0, D_MAX, n)
z = .5 * np.cos(np.linspace(0, T_MAX, NUM_FRAMES))
t = .5 * np.sin(np.linspace(0, T_MAX, NUM_FRAMES))
NUM_LAYERS = 3
canvas = np.zeros((len(x), len(y), NUM_LAYERS)).astype(int)
NUM_SAMPLE_LAYERS = 2
samples = np.zeros((len(x), len(y), NUM_SAMPLE_LAYERS))
palette = {
0: [73, 89, 103],
1: [189, 213, 234],
2: [87, 115, 153],
3: [255, 79, 121]
}
from opensimplex import OpenSimplex
import numpy as np
from PIL import Image
import math
import random
seed = OpenSimplex(random.randint(0, 1000)) # object used to generate noise
w, h = 400, 300 # dimensions of the map
f = 0.03 # base frequency. scales frequency of all octaves
hvar = 5.0 # height variance. used to alter height values to a more desirable level
elevation = [[0 for x in range(w)] for y in range(h)]
maxE, maxA, maxB, maxC = -999.0, -999.0, -999.0, -999.0
minE, minA, minB, minC = 999.0, 999.0, 999.0, 999.0
def simplex(x, y): # simplex algorithm used to create noise for height map
return (seed.noise2d(x, y) + 1) / 2
def adjustment_function(
num,
pow): # adjusts heights of elevation map to make stronger contrasts
return math.pow(num, pow) # currently just original raised to a power
class Octave:
def __init__(self, weight, frequency, array):
self.weight = weight
self.frequency = frequency
self.array = array
print("\ncreated octave with weight: " + str(self.weight) +
class Terrain(object):
def __init__(self, song):
self.app = QtGui.QApplication(sys.argv)
self.window = gl.GLViewWidget()
self.window.setGeometry(0, 200, 1280, 720)
self.window.show()
self.window.setWindowTitle('Terrain')
self.window.setCameraPosition(distance=28, elevation=2, azimuth=0)
self.nstep = 1
self.ypoints1 = [i for i in range(-25, 26, self.nstep)]
self.xpoints1 = [i for i in range(-52, -1, self.nstep)]
self.ypoints2 = [i for i in range(-25, 26, self.nstep)]
self.xpoints2 = [i for i in range(2, 53, self.nstep)]
self.nfaces = len(self.ypoints1)
self.perlin = OpenSimplex()
self.offset = 0
self.beat, self.posbeat = self.BeatMaker(song)
self.beatindex = 0
self.color_choice = [{
"R": (117 / 255),
"G": (221 / 255),
"B": (221 / 255)
}, {
"R": (25 / 255),
"G": (123 / 255),
"B": (189 / 255)
}, {
"R": (11 / 255),
"G": (19 / 255),
"B": (43 / 255)
}, {
"R": (144 / 255),
"G": (41 / 255),
"B": (35 / 255)
}, {
"R": (144 / 255),
"G": (41 / 255),
"B": (35 / 255)
}]
def mesh_init(X, Y, Ampli):
verts = np.array([[
x, y,
Ampli * self.perlin.noise2d(x=x / 5, y=y / 5 + self.offset)
] for x in X for y in Y],
dtype=np.float32)
faces = []
colors = []
for m in range(self.nfaces - 1):
yoff = m * self.nfaces
for n in range(self.nfaces - 1):
faces.append([
n + yoff, yoff + n + self.nfaces,
yoff + n + self.nfaces + 1
])
faces.append(
[n + yoff, yoff + n + 1, yoff + n + self.nfaces + 1])
colors.append(
[int(117 / 255),
int(221 / 255),
int(221 / 255), 0.78])
colors.append(
[int(117 / 255),
int(221 / 255),
int(221 / 255), 0.8])
return np.array(verts), np.array(faces), np.array(colors)
verts1, faces1, colors1 = mesh_init(self.ypoints1, self.xpoints1, 0.2)
verts2, faces2, colors2 = mesh_init(self.ypoints2, self.xpoints2, 0.2)
self.m1 = gl.GLMeshItem(
vertexes=verts1,
faces=faces1,
faceColors=colors1,
smooth=False,
drawEdges=False,
)
self.m1.setGLOptions('additive')
self.window.addItem(self.m1)
self.m2 = gl.GLMeshItem(
vertexes=verts2,
faces=faces2,
faceColors=colors2,
smooth=False,
drawEdges=False,
)
self.m2.setGLOptions('additive')
self.window.addItem(self.m2)
def start(self):
"""
get the graphics window open and setup
"""
if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
QtGui.QApplication.instance().exec_()
def animation(self):
"""
calls the update method to run in a loop
"""
timer = QtCore.QTimer()
timer.timeout.connect(self.update)
timer.start(10)
self.start()
self.update()
def update(self):
"""
update the mesh and shift the noise each time
"""
def mesh_init(X, Y, Ampli):
verts = np.array([[
x, y,
Ampli * self.perlin.noise2d(x=(x / 5) + self.offset, y=(y / 5))
] for x in X for y in Y],
dtype=np.float32)
faces = []
colors = []
a = int(self.posbeat[self.beatindex] * 4)
if a > 4:
a = 4
color = self.color_choice[a]
for m in range(self.nfaces - 1):
yoff = m * self.nfaces
for n in range(self.nfaces - 1):
faces.append([
n + yoff, yoff + n + self.nfaces,
yoff + n + self.nfaces + 1
])
faces.append(
[n + yoff, yoff + n + 1, yoff + n + self.nfaces + 1])
colors.append([color["R"], color["G"], color["B"], 0.795])
colors.append([color["R"], color["G"], color["B"], 0.8])
return np.array(verts), np.array(faces), np.array(colors)
if self.beatindex < len(self.beat):
verts1, faces1, colors1 = mesh_init(self.ypoints1, self.xpoints1,
3 * self.beat[self.beatindex])
verts2, faces2, colors2 = mesh_init(self.ypoints2, self.xpoints2,
3 * self.beat[self.beatindex])
self.m1.setMeshData(vertexes=verts1,
faces=faces1,
faceColors=colors1)
self.m2.setMeshData(vertexes=verts2,
faces=faces2,
faceColors=colors2)
self.offset -= 0.18
self.window.grabFrameBuffer().save("frames10/" +
str(self.beatindex) + '.png')
self.beatindex += 1
else:
print("done")
def BeatMaker(self, song):
spf = wave.open(song, "r")
signal = spf.readframes(-1)
signal = np.frombuffer(signal, "int16")
signal = signal.astype(float)
fs = spf.getframerate()
print(fs)
print(len(signal))
signal = np.array([signal[t] for t in range(0, 3639500, 2900)])
print(len(signal))
return signal / np.max(signal), np.absolute(2 * signal /
np.max(signal))
def __init__(self, song):
self.app = QtGui.QApplication(sys.argv)
self.window = gl.GLViewWidget()
self.window.setGeometry(0, 200, 1280, 720)
self.window.show()
self.window.setWindowTitle('Terrain')
self.window.setCameraPosition(distance=28, elevation=2, azimuth=0)
self.nstep = 1
self.ypoints1 = [i for i in range(-25, 26, self.nstep)]
self.xpoints1 = [i for i in range(-52, -1, self.nstep)]
self.ypoints2 = [i for i in range(-25, 26, self.nstep)]
self.xpoints2 = [i for i in range(2, 53, self.nstep)]
self.nfaces = len(self.ypoints1)
self.perlin = OpenSimplex()
self.offset = 0
self.beat, self.posbeat = self.BeatMaker(song)
self.beatindex = 0
self.color_choice = [{
"R": (117 / 255),
"G": (221 / 255),
"B": (221 / 255)
}, {
"R": (25 / 255),
"G": (123 / 255),
"B": (189 / 255)
}, {
"R": (11 / 255),
"G": (19 / 255),
"B": (43 / 255)
}, {
"R": (144 / 255),
"G": (41 / 255),
"B": (35 / 255)
}, {
"R": (144 / 255),
"G": (41 / 255),
"B": (35 / 255)
}]
def mesh_init(X, Y, Ampli):
verts = np.array([[
x, y,
Ampli * self.perlin.noise2d(x=x / 5, y=y / 5 + self.offset)
] for x in X for y in Y],
dtype=np.float32)
faces = []
colors = []
for m in range(self.nfaces - 1):
yoff = m * self.nfaces
for n in range(self.nfaces - 1):
faces.append([
n + yoff, yoff + n + self.nfaces,
yoff + n + self.nfaces + 1
])
faces.append(
[n + yoff, yoff + n + 1, yoff + n + self.nfaces + 1])
colors.append(
[int(117 / 255),
int(221 / 255),
int(221 / 255), 0.78])
colors.append(
[int(117 / 255),
int(221 / 255),
int(221 / 255), 0.8])
return np.array(verts), np.array(faces), np.array(colors)
verts1, faces1, colors1 = mesh_init(self.ypoints1, self.xpoints1, 0.2)
verts2, faces2, colors2 = mesh_init(self.ypoints2, self.xpoints2, 0.2)
self.m1 = gl.GLMeshItem(
vertexes=verts1,
faces=faces1,
faceColors=colors1,
smooth=False,
drawEdges=False,
)
self.m1.setGLOptions('additive')
self.window.addItem(self.m1)
self.m2 = gl.GLMeshItem(
vertexes=verts2,
faces=faces2,
faceColors=colors2,
smooth=False,
drawEdges=False,
)
self.m2.setGLOptions('additive')
self.window.addItem(self.m2)
def __init__(self, song):
self.app = QtGui.QApplication(sys.argv)
self.window = gl.GLViewWidget()
self.window.setGeometry(0, 500, 1280, 720)
self.window.show()
self.window.setWindowTitle('Terrain')
self.window.setCameraPosition(pos=QtGui.QVector3D(0, 0, 0),
distance=105,
elevation=0,
azimuth=90)
self.nstep = 1
self.ypoints1 = [i for i in range(-200, 201, self.nstep)]
self.xpoints1 = [i for i in range(-10, 11, self.nstep)]
self.ypoints2 = [i for i in range(-200, 201, self.nstep)]
self.xpoints2 = [i for i in range(-10, 11, self.nstep)]
self.nfaces1 = len(self.ypoints1)
self.nfaces2 = len(self.xpoints1)
self.perlin = OpenSimplex()
self.offset = 0
self.beat, self.posbeat = self.BeatMaker(song)
self.beatindex = 0
self.t = 0
self.color_choice = [{
"R": (115 / 255),
"G": (115 / 255),
"B": (115 / 255)
}, {
"R": (64 / 255),
"G": (64 / 255),
"B": (64 / 255)
}, {
"R": (38 / 255),
"G": (38 / 255),
"B": (38 / 255)
}, {
"R": (38 / 255),
"G": (38 / 255),
"B": (38 / 255)
}, {
"R": (11 / 255),
"G": (19 / 255),
"B": (43 / 255)
}]
def mesh_init(X, Y, z, Ampli):
verts = np.array([[
x, y,
z + Ampli * self.perlin.noise2d(x=x / 5, y=y / 5 + self.offset)
] for x in X for y in Y],
dtype=np.float32)
# for j in range(0, len(verts)):
# if abs(verts[j, 1]) > 20:
# verts[j, 2] = 100
faces = []
colors = []
for m in range(self.nfaces2 - 1):
yoff = m * self.nfaces2
for n in range(self.nfaces1 - 1):
faces.append([
n + yoff, yoff + n + self.nfaces1,
yoff + n + self.nfaces1 + 1
])
faces.append(
[n + yoff, yoff + n + 1, yoff + n + self.nfaces1 + 1])
colors.append(
[int(117 / 255),
int(221 / 255),
int(221 / 255), 1])
colors.append(
[int(117 / 255),
int(221 / 255),
int(221 / 255), 1])
return np.array(verts), np.array(faces), np.array(colors)
verts1, faces1, colors1 = mesh_init(self.ypoints1, self.xpoints1, 5,
0.2)
verts2, faces2, colors2 = mesh_init(self.ypoints2, self.xpoints2, -5,
0.2)
self.m1 = gl.GLMeshItem(
vertexes=verts1,
faces=faces1,
faceColors=colors1,
smooth=False,
drawEdges=False,
)
self.m1.setGLOptions('additive')
self.window.addItem(self.m1)
self.m2 = gl.GLMeshItem(
vertexes=verts2,
faces=faces2,
faceColors=colors2,
smooth=False,
drawEdges=False,
)
self.m2.setGLOptions('additive')
self.window.addItem(self.m2)
class Terrain(object):
def __init__(self, song):
self.app = QtGui.QApplication(sys.argv)
self.window = gl.GLViewWidget()
self.window.setGeometry(0, 500, 1280, 720)
self.window.show()
self.window.setWindowTitle('Terrain')
self.window.setCameraPosition(pos=QtGui.QVector3D(0, 0, 0),
distance=105,
elevation=0,
azimuth=90)
self.nstep = 1
self.ypoints1 = [i for i in range(-200, 201, self.nstep)]
self.xpoints1 = [i for i in range(-10, 11, self.nstep)]
self.ypoints2 = [i for i in range(-200, 201, self.nstep)]
self.xpoints2 = [i for i in range(-10, 11, self.nstep)]
self.nfaces1 = len(self.ypoints1)
self.nfaces2 = len(self.xpoints1)
self.perlin = OpenSimplex()
self.offset = 0
self.beat, self.posbeat = self.BeatMaker(song)
self.beatindex = 0
self.t = 0
self.color_choice = [{
"R": (115 / 255),
"G": (115 / 255),
"B": (115 / 255)
}, {
"R": (64 / 255),
"G": (64 / 255),
"B": (64 / 255)
}, {
"R": (38 / 255),
"G": (38 / 255),
"B": (38 / 255)
}, {
"R": (38 / 255),
"G": (38 / 255),
"B": (38 / 255)
}, {
"R": (11 / 255),
"G": (19 / 255),
"B": (43 / 255)
}]
def mesh_init(X, Y, z, Ampli):
verts = np.array([[
x, y,
z + Ampli * self.perlin.noise2d(x=x / 5, y=y / 5 + self.offset)
] for x in X for y in Y],
dtype=np.float32)
# for j in range(0, len(verts)):
# if abs(verts[j, 1]) > 20:
# verts[j, 2] = 100
faces = []
colors = []
for m in range(self.nfaces2 - 1):
yoff = m * self.nfaces2
for n in range(self.nfaces1 - 1):
faces.append([
n + yoff, yoff + n + self.nfaces1,
yoff + n + self.nfaces1 + 1
])
faces.append(
[n + yoff, yoff + n + 1, yoff + n + self.nfaces1 + 1])
colors.append(
[int(117 / 255),
int(221 / 255),
int(221 / 255), 1])
colors.append(
[int(117 / 255),
int(221 / 255),
int(221 / 255), 1])
return np.array(verts), np.array(faces), np.array(colors)
verts1, faces1, colors1 = mesh_init(self.ypoints1, self.xpoints1, 5,
0.2)
verts2, faces2, colors2 = mesh_init(self.ypoints2, self.xpoints2, -5,
0.2)
self.m1 = gl.GLMeshItem(
vertexes=verts1,
faces=faces1,
faceColors=colors1,
smooth=False,
drawEdges=False,
)
self.m1.setGLOptions('additive')
self.window.addItem(self.m1)
self.m2 = gl.GLMeshItem(
vertexes=verts2,
faces=faces2,
faceColors=colors2,
smooth=False,
drawEdges=False,
)
self.m2.setGLOptions('additive')
self.window.addItem(self.m2)
def start(self):
"""
get the graphics window open and setup
"""
if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
QtGui.QApplication.instance().exec_()
def animation(self):
"""
calls the update method to run in a loop
"""
# timer = QtCore.QTimer()
# timer.timeout.connect(self.update)
# timer.start(10)
self.start()
def update(self):
"""
update the mesh and shift the noise each time
"""
def mesh_init(X, Y, z, Ampli, signe):
verts = np.array([[
x + (Ampli / 1.5) * self.perlin.noise2d(
x=y / 10, y=y / 10 - self.offset + self.offset), y,
(z + signe * np.sqrt(10**2 - x**2) - signe * Ampli *
self.perlin.noise2d(x=x / 5, y=y / 5 + self.offset))
] if abs(x) < 10 else [x, y, 0] for y in Y for x in X],
dtype=np.float32)
faces = []
colors = []
a = int(self.posbeat[self.beatindex] * 4)
if a > 4:
a = 4
color = self.color_choice[a]
# print(color["R"])
for m in range(self.nfaces1 - 1):
yoff = m * self.nfaces2
for n in range(self.nfaces2 - 1):
faces.append([
n + yoff, yoff + n + self.nfaces2,
yoff + n + self.nfaces2 + 1
])
faces.append(
[n + yoff, yoff + n + 1, yoff + self.nfaces2 + n + 1])
colors.append([color["R"], color["G"], color["B"], 1])
colors.append([color["R"], color["G"], color["B"], 0.995])
return np.array(verts), np.array(faces), np.array(colors)
stime = time.time()
if self.beatindex < len(self.beat):
verts1, faces1, colors1 = mesh_init(self.xpoints1, self.ypoints1,
0,
10 * self.beat[self.beatindex],
1)
verts2, faces2, colors2 = mesh_init(self.xpoints2, self.ypoints2,
0,
10 * self.beat[self.beatindex],
-1)
self.m1.setMeshData(vertexes=verts1,
faces=faces1,
faceColors=colors1)
self.m2.setMeshData(vertexes=verts2,
faces=faces2,
faceColors=colors2)
self.window.setCameraPosition(
pos=QtGui.QVector3D(0, 0, 0),
distance=200,
elevation=4 *
(self.perlin.noise2d(x=self.beat[self.beatindex + 1],
y=self.beat[self.beatindex])),
azimuth=90 + 4 *
(self.perlin.noise2d(x=self.beat[self.beatindex + 1],
y=self.beat[self.beatindex])))
self.offset -= 0.2
self.window.grabFrameBuffer().save("frames/" +
str(self.beatindex) + '.png')
self.beatindex += 1
else:
print("done")
self.t += (time.time() - stime) / 30
print('{:.0f} FPS'.format(self.t))
def BeatMaker(self, song):
spf = wave.open(song, "r")
signal = spf.readframes(-1)
signal = np.frombuffer(signal, "int16")
signal = signal.astype(float)
fs = spf.getframerate()
print(fs)
signal = np.array(
[signal[t] for t in range(0, len(signal), int((2 * fs) / 30))])
signalabs = np.absolute(signal)
return (signal - np.mean(signal)) / (
np.max(signal) - np.min(signal)), 5 * np.absolute(
signalabs - np.mean(signalabs) /
(np.max(signalabs) - np.min(signalabs))) / max(
np.absolute(signalabs - np.mean(signalabs) /
(np.max(signalabs) - np.min(signalabs))))
if not os.path.isfile(imagePath):
print(imagePath, "can't be found")
exit()
img = cv2.imread(imagePath)
if img is None:
print(imagePath, "is not an image")
exit()
img = cv2.resize(img, None, fx=INPUT_SCALE, fy=INPUT_SCALE)
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
h, s, v = cv2.split(hsv)
simplex = OpenSimplex()
noise = np.zeros((20, 20))
pb = ProgressBar(total=NB_FRAMES - 1,
decimals=1,
length=40,
fill='-',
zfill=' ')
print("Your animation is in process : ")
for step in range(NB_FRAMES):
stepPercent = step / NB_FRAMES
pb.print_progress_bar(step)
tx = dT * math.cos(stepPercent * 2 * math.pi)
import numpy
from PIL import Image
from opensimplex import OpenSimplex
WIDTH = 64
OPEN_SIMPLEX = OpenSimplex(seed=12345)
def main():
im = Image.new('L', (WIDTH, WIDTH))
for y in range(WIDTH):
for x in range(WIDTH):
value = OPEN_SIMPLEX.noise2d(x / 8., y / 8.)
color = int((value + 1.) * 128.)
im.putpixel((x, y), color)
im.show()
def _main():
data = numpy.zeros((WIDTH, WIDTH, 3), dtype=numpy.uint8)
for _y in range(WIDTH):
row = data[_y]
for _x in range(WIDTH):
_v = (OPEN_SIMPLEX.noise2d(_x / 8., _y / 8.) + 1.) * 128.
row[_x] = [_v, _v, _v]
img = Image.fromarray(data)
img.show() # View in default viewer
def __init__(self):
self.chunk_array = np.empty((15, 15), dtype=object)
self.spnoise = OpenSimplex()
import pygame
import sys
import random
import math
from opensimplex import OpenSimplex
filters = 4
timer = pygame.time.Clock()
screen = pygame.display.set_mode((400, 400))
pygame.display.set_caption("clowd")
surface = pygame.Surface((400, 400), pygame.SRCALPHA)
seed = OpenSimplex(random.randint(1, 100))
for i in range(400):
for j in range(100):
density = max(
seed.noise2d(x=i / 80, y=j / 20) * 250 *
math.sin(math.pi * j / 100), 0)
pygame.draw.rect(surface, (255, 255, 255, density),
pygame.Rect(i, j + 100, 1, 1))
screen.blit(surface, (0, 0))
frames = 400
while True:
surface.scroll(dx=-1)
pygame.draw.rect(surface, (0, 0, 0, 0), pygame.Rect(399, 0, 1, 400))
for j in range(100):
density = max(
seed.noise2d(x=frames / 80, y=j / 20) * 250 *
math.sin(math.pi * j / 100), 0)
pygame.draw.rect(surface, (255, 255, 255, density),
pygame.Rect(399, j + 100, 1, 1))
class Mesh:
def __init__(self): # pass in self, and the app & view attributes
self.app = QtGui.QApplication(
sys.argv
) # the window titl this be the GUI for our project, allowing us to see all of the visuals
self.view = gl.GLViewWidget(
) # this is going to be the view widget that we need to be able to add meshes
self.view.show() # shows the view widget
self.view.setWindowTitle(
'Mesh') #sets the window title to whatever we want
self.noise = OpenSimplex()
self.offSet = 0 # change the noise value as we loop through the animation
self.RATE = 44100 # standard refresh rate for videos
self.CHUNK = 1024 # standard chunk size for data; this is why our grid is 32 x 32
self.audioData = None # this will keep track of the audio data we read
self.p = pyaudio.PyAudio() # instance of a pyaudio class
self.stream = self.p.open(
format=pyaudio.paInt16,
channels=1,
rate=self.RATE,
input=True,
output=True,
frames_per_buffer=self.CHUNK) # this is how we read audio data
vertices = [] # vertices is an np array of [x, y, z] coordinates
for row in range(32): # row corresponds to the y value
for col in range(32): # col corresponds to the x value
vertices.append([
col, row, self.noise.noise2d(x=row, y=col)
]) # add noise to the z coord to create a random terrain
faces = [
] # faces is an np array of [vertex1, vertex2, vertex3] using indices from the vertices np array
for n in range(31): # row
for k in range(31): # column
# first point of FIRST triangle; to the right of the first; directly below the first
faces.append([n * 32 + k, n * 32 + k + 1, (n + 1) * 32 + k])
# first point of SECOND triangle (same as last point of first triangle); to the right of the first; at the top (same as second position of first triangle)
faces.append([(n + 1) * 32 + k, (n + 1) * 32 + k + 1,
n * 32 + k + 1])
colors = []
for i in range(341): #ratio between 0 to 1 ...divide by length of row
colors.append([1, 0, 0, 0.6])
colors.append([0, 1, 0, 0.6])
colors.append([0, 0, 1, 0.6])
colors.append([1, 0, 0, 0.6])
v = np.array(vertices)
f = np.array(faces)
c = np.array(colors)
self.mesh = gl.GLMeshItem(vertexes=v, faces=f, faceColors=c)
self.mesh.setGLOptions("additive")
self.view.addItem(self.mesh)
self.view.setWindowTitle('me$h')
def update(self):
self.audioData = self.stream.read(
self.CHUNK, exception_on_overflow=False
) # this reads incoming audiodata self.CHUNK bytes at a time
# important to set exception_on_overflow in line above to False in order to prevent program from crashing
audio_obj = struct.unpack(str(2 * self.CHUNK) + 'B', self.audioData)
audio_obj = np.array(audio_obj, dtype='b')[::2] + 128
audio_obj = np.array(audio_obj, dtype='int32') - 128
audio_obj = audio_obj * 0.04
audio_obj = audio_obj.reshape(32, 32)
vertices = [] # vertices is an np array of [x, y, z] coordinates
for row in range(32): # row corresponds to the y value
for col in range(32): # col corresponds to the x value
vertices.append([
col, row, audio_obj[row][col] * self.noise.noise2d(
x=row + self.offSet, y=col + self.offSet)
])
self.offSet -= 0.1 # each time the update function gets called, self.offSet decrements by 0.1
faces = [
] # faces is an np array of [vertex1, vertex2, vertex3] using indices from the vertices np array
for n in range(31): # row
for k in range(31): # column
# first point of FIRST triangle; to the right of the first; directly below the first
faces.append([n * 32 + k, n * 32 + k + 1, (n + 1) * 32 + k])
# first point of SECOND triangle (same as last point of first triangle); to the right of the first; at the top (same as second position of first triangle)
faces.append([(n + 1) * 32 + k, (n + 1) * 32 + k + 1,
n * 32 + k + 1])
colors = []
for i in range(341): #ratio between 0 to 1 ...divide by length of row
colors.append([1, 0, 0, 0.6])
colors.append([0, 1, 0, 0.6])
colors.append([0, 0, 1, 0.6])
colors.append([1, 0, 0, 0.6])
v = np.array(vertices)
f = np.array(faces)
c = np.array(colors)
self.mesh.setMeshData(vertexes=v,
faces=f,
vertexColors=c,
drawEdges=True)
def animation(self):
timer = QtCore.QTimer()
timer.timeout.connect(self.update)
timer.start(10)
self.run() # call the start function to kick off animation
self.update() # call the update function to kick off animation
def run(
self
): # this function actually executes our Mesh instance and enables the GUI to run!
if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
QtGui.QApplication.instance().exec_()
from opensimplex import OpenSimplex
from random import randint
"""
SETUP
"""
# Constants
WIDTH = 200
HEIGHT = 200
RESOLUTION = 7 #Larger value makes scale larger and more smooth
SEED = randint(1, 10000000)
# Variables
_map = []
ops = OpenSimplex(seed=SEED)
"""
FUNCTIONS
"""
def fillBlank(mapp):
mapp.clear()
for y in range(HEIGHT):
mapp.append([-1] * WIDTH)
def printMap():
for y in range(HEIGHT):
print(_map[y])
def fileWrite():
from opensimplex import OpenSimplex
from config import SEED, WIDTH, LENGTH, PAD, UNPADDED_LENGTH, UNPADDED_WIDTH
import numpy as np
xs = np.linspace(start=0, stop=UNPADDED_WIDTH - 1, num=UNPADDED_WIDTH)
ys = np.linspace(start=0, stop=UNPADDED_LENGTH - 1, num=UNPADDED_LENGTH)
xs, ys = np.meshgrid(xs, ys)
xs_longer = np.linspace(start=0, stop=WIDTH - 1, num=WIDTH)
ys_longer = np.linspace(start=0, stop=LENGTH - 1, num=LENGTH)
xs_longer, ys_longer = np.meshgrid(xs_longer, ys_longer)
gen = OpenSimplex(seed=SEED)
def gradient_array():
x_rad = np.ones_like(xs) - abs(xs - UNPADDED_WIDTH / 2) / (UNPADDED_WIDTH *
0.5)
y_rad = np.ones_like(ys) - abs(ys - UNPADDED_WIDTH / 2) / (UNPADDED_WIDTH *
0.5)
return np.sqrt(x_rad * y_rad)
def noise_layer(frequency, length=UNPADDED_LENGTH, width=UNPADDED_WIDTH):
layer = np.zeros((length, width))
for x in range(length):
for y in range(width):
layer[x, y] += gen.noise2d(x * frequency / length,
y * frequency / width)
return layer
class Terrain(object):
def __init__(self):
"""
Initialize the graphics window and mesh
"""
# setup the view window
self.app = QtGui.QApplication(sys.argv)
self.w = gl.GLViewWidget()
self.w.setGeometry(0, 110, 1920, 1080)
self.w.show()
self.w.setWindowTitle('Terrain')
self.w.setCameraPosition(distance=30, elevation=8)
# constants and arrays
self.nsteps = 1
self.ypoints = range(-20, 22, self.nsteps)
self.xpoints = range(-20, 22, self.nsteps)
self.nfaces = len(self.ypoints)
self.offset = 0
# perlin noise object
self.tmp = OpenSimplex()
# create the veritices array
verts = np.array([
[
x, y, 1.5 * self.tmp.noise2d(x=n / 5, y=m / 5)
] for n, x in enumerate(self.xpoints) for m, y in enumerate(self.ypoints)
], dtype=np.float32)
# create the faces and colors arrays
faces = []
colors = []
for m in range(self.nfaces - 1):
yoff = m * self.nfaces
for n in range(self.nfaces - 1):
faces.append([n + yoff, yoff + n + self.nfaces, yoff + n + self.nfaces + 1])
faces.append([n + yoff, yoff + n + 1, yoff + n + self.nfaces + 1])
colors.append([0, 0, 0, 0])
colors.append([0, 0, 0, 0])
faces = np.array(faces)
colors = np.array(colors)
# create the mesh item
self.m1 = gl.GLMeshItem(
vertexes=verts,
faces=faces, faceColors=colors,
smooth=False, drawEdges=True,
)
self.m1.setGLOptions('additive')
self.w.addItem(self.m1)
def update(self):
"""
update the mesh and shift the noise each time
"""
verts = np.array([
[
x, y, 2.5 * self.tmp.noise2d(x=n / 5 + self.offset, y=m / 5 + self.offset)
] for n, x in enumerate(self.xpoints) for m, y in enumerate(self.ypoints)
], dtype=np.float32)
faces = []
colors = []
for m in range(self.nfaces - 1):
yoff = m * self.nfaces
for n in range(self.nfaces - 1):
faces.append([n + yoff, yoff + n + self.nfaces, yoff + n + self.nfaces + 1])
faces.append([n + yoff, yoff + n + 1, yoff + n + self.nfaces + 1])
colors.append([n / self.nfaces, 1 - n / self.nfaces, m / self.nfaces, 0.7])
colors.append([n / self.nfaces, 1 - n / self.nfaces, m / self.nfaces, 0.8])
faces = np.array(faces, dtype=np.uint32)
colors = np.array(colors, dtype=np.float32)
self.m1.setMeshData(
vertexes=verts, faces=faces, faceColors=colors
)
self.offset -= 0.18
def start(self):
"""
get the graphics window open and setup
"""
if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
QtGui.QApplication.instance().exec_()
def animation(self):
"""
calls the update method to run in a loop
"""
timer = QtCore.QTimer()
timer.timeout.connect(self.update)
timer.start(10)
self.start()
self.update()
def generate_heightmap(self, env_name, env_length, current_height):
if env_name == "flat":
hm = np.ones((self.env_width, env_length)) * current_height
if env_name == "tiles":
sf = 3
hm = np.random.randint(0, 55,
size=(self.env_width // sf, env_length // sf)).repeat(sf, axis=0).repeat(sf, axis=1)
hm_pad = np.zeros((self.env_width, env_length))
hm_pad[:hm.shape[0], :hm.shape[1]] = hm
hm = hm_pad + current_height
if env_name == "pipe":
pipe_form = np.square(np.linspace(-1.2, 1.2, self.env_width))
pipe_form = np.clip(pipe_form, 0, 1)
hm = 255 * np.ones((self.env_width, env_length)) * pipe_form[np.newaxis, :].T
hm += current_height
if env_name == "holes":
hm = cv2.imread(os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets/holes1.png"))
h, w, _ = hm.shape
patch_y = 14
patch_x = int(14 * self.s_len / 150.)
rnd_h = np.random.randint(0, h - patch_x)
rnd_w = np.random.randint(0, w - patch_y)
hm = hm[rnd_w:rnd_w + patch_y, rnd_h:rnd_h + patch_x]
hm = np.mean(hm, axis=2)
hm = hm * 1.0 + 255 * 0.3
hm = cv2.resize(hm, dsize=(env_length, self.env_width), interpolation=cv2.INTER_CUBIC) / 2.
if env_name == "inverseholes":
hm = cv2.imread(os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets/holes1.png"))
h, w, _ = hm.shape
patchsize = 10
while True:
rnd_h = np.random.randint(0, h - patchsize)
rnd_w = np.random.randint(0, w - patchsize)
hm_tmp = hm[rnd_w:rnd_w + patchsize, rnd_h:rnd_h + patchsize]
#assert hm.shape == (10,10,3)
if np.min(hm_tmp[:, :2, :]) > 160: break
hm = np.mean(hm_tmp, axis=2)
hm = cv2.resize(hm, dsize=(env_length, self.env_width), interpolation=cv2.INTER_CUBIC)
hm = 255 - hm
hm *= 0.5
hm += 127
if env_name == "bumps":
hm = cv2.imread(os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets/bumps2.png"))
h, w, _ = hm.shape
patchsize = 50
rnd_h = np.random.randint(0, h - patchsize)
rnd_w = np.random.randint(0, w - patchsize)
hm = hm[rnd_w:rnd_w + patchsize, rnd_h:rnd_h + patchsize]
hm = np.mean(hm, axis=2)
hm = cv2.resize(hm, dsize=(env_length, self.env_width), interpolation=cv2.INTER_CUBIC) / 2. + 127
if env_name == "stairs":
hm = np.ones((self.env_width, env_length)) * current_height
stair_height = 45
stair_width = 4
initial_offset = 0
n_steps = math.floor(env_length / stair_width) - 1
for i in range(n_steps):
hm[:, initial_offset + i * stair_width: initial_offset + i * stair_width + stair_width] = current_height
current_height += stair_height
hm[:, n_steps * stair_width:] = current_height
if env_name == "verts":
wdiv = 4
ldiv = 14
hm = np.random.randint(0, 75,
size=(self.env_width // wdiv, env_length // ldiv),
dtype=np.uint8).repeat(wdiv, axis=0).repeat(ldiv, axis=1)
hm[:, :50] = 0
hm[hm < 50] = 0
hm = 75 - hm
if env_name == "triangles":
cw = 10
# Make even dimensions
M = math.ceil(self.env_width)
N = math.ceil(env_length)
hm = np.zeros((M, N), dtype=np.float32)
M_2 = math.ceil(M / 2)
# Amount of 'tiles'
Mt = 2
Nt = int(env_length / 10.)
obstacle_height = 50
grad_mat = np.linspace(0, 1, cw)[:, np.newaxis].repeat(cw, 1)
template_1 = np.ones((cw, cw)) * grad_mat * grad_mat.T * obstacle_height
template_2 = np.ones((cw, cw)) * grad_mat * obstacle_height
for i in range(Nt):
if np.random.choice([True, False]):
hm[M_2 - cw: M_2, i * cw: i * cw + cw] = np.rot90(template_1, np.random.randint(0, 4))
else:
hm[M_2 - cw: M_2, i * cw: i * cw + cw] = np.rot90(template_2, np.random.randint(0, 4))
if np.random.choice([True, False]):
hm[M_2:M_2 + cw:, i * cw: i * cw + cw] = np.rot90(template_1, np.random.randint(0, 4))
else:
hm[M_2:M_2 + cw:, i * cw: i * cw + cw] = np.rot90(template_2, np.random.randint(0, 4))
hm += current_height
if env_name == "perlin":
oSim = OpenSimplex(seed=int(time.time()))
height = 100
M = math.ceil(self.env_width)
N = math.ceil(env_length)
hm = np.zeros((M, N), dtype=np.float32)
scale_x = 20
scale_y = 20
octaves = 4 # np.random.randint(1, 5)
persistence = 1
lacunarity = 2
for i in range(M):
for j in range(N):
for o in range(octaves):
sx = scale_x * (1 / (lacunarity ** o))
sy = scale_y * (1 / (lacunarity ** o))
amp = persistence ** o
hm[i][j] += oSim.noise2d(i / sx, j / sy) * amp
wmin, wmax = hm.min(), hm.max()
hm = (hm - wmin) / (wmax - wmin) * height
hm += current_height
return hm, current_height
import math, os
from opensimplex import OpenSimplex
gen = OpenSimplex()
def noise(nx, ny, freq, octave, power):
sum_ = 0
if octave == 0:
octave = 1
#for x in range(1, octave):
# sum_ += (1/x)*gen.noise2d(freq*nx*(x**2), freq*ny*(x**2)) / 2.0 + 0.5
for x in range(1, octave):
sum_ += (1 / float(x)) * (gen.noise2d(freq * nx *
(2**x), freq * ny *
(2**x)) / 2.0 + 0.5)
#sum_ = gen.noise2d(freq*nx, freq*ny) + 0.5*gen.noise2d(2*freq*nx, 2*freq*ny) + 0.25*gen.noise2d(4*freq*nx, 4*freq*nx)#/ 2.0 + 0.5
return (sum_)**power
def convert_to_terrain(num, blocks):
for n in range(1, blocks + 1):
if num < (float(n) / blocks):
return n
elif num > 1:
return 1
def wanking_cunt(x_width, y_height, freq, octaves, power, features):
array = []
if not os.path.exists('map.dat'):
def __init__(self):
self.gen = OpenSimplex(random.randint(0, sys.maxint))
def draw_field(field, guide=None, N_particles=50000, vis=False):
''' draw vector field
args:
field - (H, W, 2) np array
guide - (H, W) np array image '''
lines = []
if guide is None:
guide_counter = np.ones(field.shape[:2])
else:
guide_counter = guide.copy()
def sample_field_point(probs, n=1):
N_points = probs.size
lin_coords = np.random.choice(N_points,
size=n,
replace=False,
p=probs.flatten())
coords = np.unravel_index(lin_coords, probs.shape)
coords = np.array(coords).T
if n == 1:
coords = coords[0]
return coords
guide_scale = 1
guide_counter = cv2.resize(guide_counter,
dsize=(0, 0),
fx=guide_scale,
fy=guide_scale)
probs = guide_counter.copy()**1.4
probs /= np.sum(probs)
max_prob = np.amax(probs)
orig_guide = guide_counter.copy()
rot_noise = OpenSimplex(117)
rot_noise_mult = 0.555
start_pts = []
H, W = field.shape[:2]
for part_i in tqdm.tqdm(range(N_particles)):
if np.random.rand() > 0.5:
sign = -1
else:
sign = 1
line = []
pos = sample_field_point(probs)
prob = probs[pos[0], pos[1]]
# pos /= guide_scale
pos = pos[::-1].astype(np.float64) # convert to (x, y)
start_pts.append(pos.copy())
# perturbation_angle = np.random.randn()
# perturbation_angle /= 3
perturbation_angle = rot_noise.noise2d(x=rot_noise_mult * pos[0],
y=rot_noise_mult * pos[1])
perturbation_angle /= 1.6
c, s = np.cos(perturbation_angle), np.sin(perturbation_angle)
perturbation_rot = np.array([[c, -s], [s, c]])
line.append(pos.copy())
particle_paint_left = (
(max_prob - prob) / max_prob)**0.5 * 30 * guide_scale
# print(f"particle_paint_left: {particle_paint_left}")
stop_line = False
vals = []
while particle_paint_left > 0:
field_pos = np.round(pos)
force = field[int(field_pos[1]), int(field_pos[0]), :]
old_pos = pos.copy()
# if np.linalg.norm(force) < 0.0001:
# force += 1
# to_add = sign * force
to_add = sign * force / np.linalg.norm(force)
to_add = np.matmul(perturbation_rot, to_add.T).T
pos += to_add
# pos = np.round(pos)
if np.logical_or(np.any(pos < 0), np.any(pos >= (W, H))):
break
segment = bresenham(old_pos, np.round(pos))
prev_xy = None
for xy in segment:
xy = np.floor(guide_scale * np.array(xy)).astype(np.int32)
if np.all(xy == prev_xy):
continue
prev_xy = xy.copy()
try:
val = orig_guide[xy[1], xy[0]].copy()
vals.append(val)
if np.abs(vals[-1] - vals[0]) > (30.0 / 256):
stop_line = True
break
particle_paint_left -= 1
if particle_paint_left <= 0:
stop_line = True
break
except IndexError:
stop_line = True
break
if np.all(force == 0):
# print('noforce')
break
line.append(pos.copy())
if stop_line:
# print('stop_line')
break
line = np.array(line)
if len(line) >= 2:
lines.append(line)
if vis:
plt.plot(line[:, 0], line[:, 1], 'k-', lw=0.1, alpha=0.5)
if vis:
plt.axis('image')
plt.gca().invert_yaxis()
# plt.figure()
# start_pts = np.array(start_pts)
# plt.plot(start_pts[:, 0], start_pts[:, 1], 'k.', markersize=0.3)
# plt.axis('image')
# plt.gca().invert_yaxis()
# plt.imshow(guide_counter)
# plt.colorbar()
plt.show()
return lines
# Noisy Fire effect, ported from
# https://gist.github.com/StefanPetrick/1ba4584e534ba99ca259c1103754e4c5
import time
import neopixel
import random
from visualisation import Visualisation
import logging
from opensimplex import OpenSimplex
from .utils import millis, scale, toRGB
import adafruit_fancyled.adafruit_fancyled as fancy
from math import sin, cos, sqrt
noise = OpenSimplex()
logger = logging.getLogger(__name__)
class NoisyColoursVisualisation(Visualisation):
def __init__(self, pixels: neopixel.NeoPixel, num_pixels: int):
super().__init__(pixels, num_pixels)
self.x = [0 for x in range(0, 100)]
self.y = [0 for x in range(0, 100)]
for i in range(0, 100):
angle = (i * 256) / 100
self.x[i] = cos(angle)
self.y[i] = sin(angle)
def doTask(self):
while self.running:
scale_val = 1000
r = x - rho * residual
x = prox_l2(r, theta)
pbar.set_postfix(iter=loop, loss=np.linalg.norm(residual))
loop += 1
return x
if (__name__ == '__main__'):
pl.close('all')
seed = np.random.randint(low=0, high=10000)
noise = OpenSimplex(seed=125) #seed=123)
# Set orbital properties
p_rotation = 23.934
p_orbit = 365.256363 * 24.0
phi_orb = np.pi
inclination = 0.0 #np.pi/2
obliquity = 90. * np.pi / 180.0
phi_rot = np.pi
nside = 16
npix = hp.nside2npix(nside)
polar_angle, azimuthal_angle = hp.pixelfunc.pix2ang(nside, np.arange(npix))
x = np.sin(polar_angle) * np.cos(azimuthal_angle)
y = np.sin(polar_angle) * np.sin(azimuthal_angle)
def __init__(self, seed=0):
self.simplex_fn = OpenSimplex(seed=seed)
for idx in range(self.strip_length):
val = self.op.noise2d(idx / self.x_div(),
self.counter / self.y_div())
val = scale(val, 0, 3, -1, 1)
self.pixels[idx]['color'] = num_to_rgb(val) + (self.color.a, )
# update counter
self.counter += 1
def num_to_rgb(val, max_val=3):
i = (val * 255 / max_val)
r = round(math.sin(0.024 * i + 0) * 127 + 128)
g = round(math.sin(0.024 * i + 2) * 127 + 128)
b = round(math.sin(0.024 * i + 4) * 127 + 128)
return (r, g, b)
if __name__ == '__main__':
import matplotlib.pyplot as plt
noise = []
op = OpenSimplex(seed=1)
for idx in range(256):
noise.append([op.noise2d(jdx / 8, idx / 8) for jdx in range(256)])
plt.imshow(noise, cmap='gray', interpolation='lanczos')
plt.colorbar()
plt.show()
def __init__(self, seed, width = 50, height = 50):
self.openSimplex = OpenSimplex(seed)
self.load_tiles(width, height)
from random import randint
from opensimplex import OpenSimplex
tmp = OpenSimplex(seed=randint(1, 100000))
#Import for main program
from PIL import Image
from tkinter import filedialog
from math import sqrt
#Initialise width / height
width = 1000
height = 1000
#Import gradient picture - 200*1 image used to texture perlin noise
#R,G,B,Alpha
gradient = Image.open("image.png")
gradlist = list(gradient.getdata())
#Create new image
img = Image.new('RGBA', (width, height), color=(255, 255, 255, 255))
def pixel(x, y):
distance = sqrt(abs(x - 3)**2 + abs(y - 3)**2)
simplex = -distance * 1.3
for r in range(0, 12):
simplex += (tmp.noise2d(x * 1.28**r, y * 1.28**r) / (r + 1) * 2.56)
simplex -= 3 * (abs(x - 5.8) + abs(x - 0.2) + abs(y - 5.8) + abs(y - 0.2) -
12)
simplex -= 2 * (abs(2 * x - 11) + abs(2 * x - 1) + abs(2 * y - 11) +
abs(2 * y - 1) - 20)
class World(object):
def __init__(self, name):
# Batch 是用于批处理渲染的顶点列表的集合
self.batch3d = pyglet.graphics.Batch()
# 透明方块
self.batch3d_transparent = pyglet.graphics.Batch()
# 为了分开绘制3D物体和2D的 HUD, 我们需要两个 Batch
self.batch2d = pyglet.graphics.Batch()
# 存档名
self.name = name
# 种子
self.seed = archiver.load_info(name)['seed']
# Simplex 噪声函数
self.simplex = OpenSimplex(seed=self.seed)
# world 存储着世界上所有的方块
self.world = {}
# 类似于 world, 但它只存储要显示的方块
self.shown = {}
self._shown = {}
# 记录玩家改变的方块
self.change = {}
self.sectors = {}
self.queue = deque()
# 初始化是否完成
self.is_init = True
def init_world(self):
# 放置所有方块以初始化世界, 非常耗时
get_game().loading.draw()
if archiver.load_info(self.name)['type'] == 'flat':
self.init_flat_world()
else:
self.init_random_world()
archiver.load_block(self.name, self.add_block, self.remove_block)
self.is_init = False
def init_flat_world(self):
# 生成平坦世界
for x in range(-MAX_SIZE, MAX_SIZE + 1):
for z in range(-MAX_SIZE, MAX_SIZE + 1):
self.add_block((x, 0, z), 'bedrock', record=False)
for x in range(-MAX_SIZE, MAX_SIZE + 1):
for y in range(1, 6):
for z in range(-MAX_SIZE, MAX_SIZE + 1):
if y == 5:
self.add_block((x, y, z), 'grass', record=False)
else:
self.add_block((x, y, z), 'dirt', record=False)
def init_random_world(self):
# 生成随机世界
for x in range(-MAX_SIZE, MAX_SIZE + 1):
for z in range(-MAX_SIZE, MAX_SIZE + 1):
self.add_block((x, 0, z), 'bedrock', record=False)
for x in range(-MAX_SIZE, MAX_SIZE + 1):
for z in range(-MAX_SIZE, MAX_SIZE + 1):
h = int(
self.simplex.noise2d(x=x / 20, y=z / 20) * 5 + SEA_LEVEL)
for y in range(1, h):
self.add_block((x, y, z), 'dirt', record=False)
else:
self.add_block((x, h, z), 'grass', record=False)
def hit_test(self, position, vector, max_distance=8):
"""
从当前位置开始视线搜索, 如果有任何方块与之相交, 返回之.
如果没有找到, 返回 (None, None)
:param: position 长度为3的元组, 当前位置
:param: vector 长度为3的元组, 视线向量
:param: max_distance 在多少方块的范围内搜索
"""
m = 8
x, y, z = position
dx, dy, dz = vector
previous = None
for _ in range(max_distance * m):
key = normalize((x, y, z))
if key != previous and key in self.world:
return key, previous
previous = key
x, y, z = x + dx / m, y + dy / m, z + dz / m
else:
return None, None
def exposed(self, position):
# 如果 position 所有的六个面旁边都有方块, 返回 False. 否则返回 True
x, y, z = position
for dx, dy, dz in FACES:
pos = (x + dx, y + dy, z + dz)
if pos not in self.world:
return True
else:
return False
def add_block(self, position, block, immediate=True, record=True):
"""
在 position 处添加一个方块
:param: pssition 长度为3的元组, 要添加方块的位置
:param: block 方块
:param: immediate 是否立即绘制方块
:param: record 是否记录方块更改(在生成地形时不记录)
"""
if position in self.world:
self.remove_block(position, immediate, record=False)
if -64 <= position[1] < 512:
# 建筑限制为-64格以上, 512格以下
if record == True:
self.change[pos2str(position)] = block
if block in blocks:
self.world[position] = blocks[block]
self.world[position].on_build(get_game(), position)
else:
# 将不存在的方块替换为 missing
self.world[position] = blocks['missing']
self.sectors.setdefault(sectorize(position), []).append(position)
if self.exposed(position):
self.show_block(position)
if not self.world[position].transparent:
self.check_neighbors(position)
else:
if position[1] >= 256:
get_game().dialogue.add_dialogue(
get_lang('game.text.build_out_of_world')[0] % 512)
else:
get_game().dialogue.add_dialogue(
get_lang('game.text.build_out_of_world')[1])
def remove_block(self, position, immediate=True, record=True):
"""
在 position 处移除一个方块
:param: position 长度为3的元组, 要移除方块的位置
:param: immediate 是否要从画布上立即移除方块
:param: record 是否记录方块更改(在 add_block 破坏后放置时不记录)
"""
if position in self.world:
# 不加这个坐标是否存在于世界中的判断有极大概率会抛出异常
self.world[position].on_destroy(get_game(), position)
del self.world[position]
if record:
self.change[pos2str(position)] = 'air'
self.sectors[sectorize(position)].remove(position)
if position in self.shown:
self.hide_block(position)
self.check_neighbors(position)
def get(self, position):
return self.world.get(position, None)
def check_neighbors(self, position):
"""
检查 position 周围所有的方块, 确保它们的状态是最新的.
这意味着将隐藏不可见的方块, 并显示可见的方块.
通常在添加或删除方块时使用.
"""
x, y, z = position
for dx, dy, dz in FACES:
key = (x + dx, y + dy, z + dz)
if key not in self.world:
continue
if self.exposed(key):
if key not in self.shown:
self.world[key].on_neighbor_change(self.world, key,
position)
self.show_block(key)
else:
if key in self.shown:
self.world[key].on_neighbor_change(self.world, key,
position)
self.hide_block(key)
def show_block(self, position, immediate=True):
"""
在 position 处显示方块, 这个方法假设方块在 add_block() 已经添加
:param: position 长度为3的元组, 要显示方块的位置
:param: immediate 是否立即显示方块
"""
block = self.world[position]
self.shown[position] = block
if immediate:
self._show_block(position, block)
else:
self._enqueue(self._show_block, position, block)
def _show_block(self, position, block):
"""
show_block() 方法的私有实现
:param: position 长度为3的元组, 要显示方块的位置
:param: block 方块
"""
vertex_data = list(block.get_vertices(*position))
texture_data = list(block.texture_data)
color_data = None
if hasattr(block, 'get_color'):
_, y, _ = position
if y <= 10:
t = 0.8
else:
t = 0.8 - (y - 0.8) * 1 / 600
h = 0.35
color_data = block.get_color(t, h)
count = len(texture_data) // 2
batch = self.batch3d
if block.transparent:
batch = self.batch3d_transparent
if color_data is None:
self._shown[position] = batch.add(count, GL_QUADS, block.group,
('v3f/static', vertex_data),
('t2f/static', texture_data))
else:
self._shown[position] = batch.add(count, GL_QUADS, block.group,
('v3f/static', vertex_data),
('t2f/static', texture_data),
('c3f/static', color_data))
def hide_block(self, position, immediate=True):
"""
隐藏在 position 处的方块, 它不移除方块
:param: position 长度为3的元组, 要隐藏方块的位置
:param: immediate 是否立即隐藏方块
"""
self.shown.pop(position)
if immediate:
self._hide_block(position)
else:
self._enqueue(self._hide_block, position)
def _hide_block(self, position):
# hide_block() 方法的私有实现
self._shown.pop(position).delete()
def show_sector(self, sector):
# 确保该区域中的方块都会被绘制
for position in self.sectors.get(sector, []):
if position not in self.shown and self.exposed(position):
self.show_block(position, False)
def hide_sector(self, sector):
# 隐藏区域
for position in self.sectors.get(sector, []):
if position in self.shown:
self.hide_block(position, False)
def change_chunk(self, before, after):
"""
改变玩家所在区域
:param: before 之前的区域
:param: after 现在的区域
"""
before_set = set()
after_set = set()
pad = 4
for dx in range(-pad, pad + 1):
for dy in [0]:
for dz in range(-pad, pad + 1):
if dx**2 + dy**2 + dz**2 > (pad + 1)**2:
continue
if before:
x, y, z = before
before_set.add((x + dx, y + dy, z + dz))
if after:
x, y, z = after
after_set.add((x + dx, y + dy, z + dz))
else:
show = after_set - before_set
hide = before_set - after_set
for sector in show:
self.show_sector(sector)
for sector in hide:
self.hide_sector(sector)
def _enqueue(self, func, *args):
# 把 func 添加到内部的队列
self.queue.append((func, args))
def _dequeue(self):
# 从内部队列顶部弹出函数并调用之
func, args = self.queue.popleft()
func(*args)
def process_queue(self):
# 处理事件
if not self.is_init:
start = time.perf_counter()
while self.queue and time.perf_counter(
) - start < 1.0 / TICKS_PER_SEC:
self._dequeue()
def process_entire_queue(self):
# 处理所有事件
while self.queue:
self._dequeue()
def draw(self):
self.batch3d.draw()
self.batch3d_transparent.draw()
