import shades
import random
from handy_stuff import palletes
MIN_SCALE = random.uniform(0, 0.5)
MAX_SCALE = MIN_SCALE + random.uniform(0, 0.5)
MAX_SIZE = random.randint(1, 5)
WALK_LENGTH = random.randint(400, 2000)
WALKERS = random.randint(300, 1500)
pallete = random.choice(palletes)
canvas = shades.Canvas(2000, 2000)
x_field, y_field = shades.noise_fields(scale=random.uniform(0.004, 0.008),
channels=2)
ink = shades.NoiseGradient(color_variance=20)
class Walker():
"""
Class to move based on noise of count, and mark point on grid
Takes xy coord as sole initialisation argument
"""
def __init__(self, xy, color=(60, 140, 180)):
self.affect = 10
self.xy = xy
self.x_noise = random.randint(0, 999)
self.y_noise = random.randint(0, 999)
self.scale = random.uniform(0, 0.6)
self.size = random.randint(1, MAX_SIZE)
ink.color = color
import shades
from random import randint
from scipy.spatial import Delaunay
canvas = shades.Canvas(1000, 1000)
ink = shades.NoiseGradient(
noise_fields=[shades.NoiseField(scale=0.002) for i in range(3)],
color=(100,150,200)
)
points = [(randint(50, canvas.width-50), randint(50, canvas.height-50)) for i in range(2000)]
# plus some edge points to make sure the whole canvas is coloured
points += [(randint(50, canvas.width-50), 50) for i in range(10)]
points += [(50, randint(50, canvas.height-50)) for i in range(10)]
points += [(randint(50, canvas.width-50), canvas.height-50) for i in range(10)]
points += [(canvas.width-50, randint(50, canvas.height-50)) for i in range(10)]
points += [(50, 50), (50, canvas.height-50), (canvas.width-50, 50), (canvas.width-50, canvas.height-50)]
# drawing triangles between points
for tri in Delaunay(points).simplices:
ink.triangle_outline(
canvas,
points[tri[0]],
points[tri[1]],
points[tri[2]],
1
)
canvas.show()
import shades
import random
from handy_stuff import palletes
canvas = shades.Canvas()
if random.random() < 0.5:
tones = [
shades.NoiseGradient((180, 180, 180),
color_fields=shades.noise_fields(scale=0.002,
channels=3))
for i in range(random.randint(2, 15))
]
else:
pallete = random.choice(palletes)
tones = [shades.BlockColor(i) for i in pallete]
shift = random.randint(10, 40)
spacing = random.randint(2, 5)
grid_size_x = random.randint(20, 30)
grid_size_y = random.randint(30, 60)
for y in range(-grid_size_y, canvas.height + grid_size_y, grid_size_y):
for i, x in enumerate(
range(-grid_size_x, canvas.width + grid_size_x, grid_size_x)):
tone = random.choice(tones)
for plus_y in range(0, grid_size_y, spacing):
if i % 2 == 0:
tone.line(canvas, (x, y + plus_y),
(x + grid_size_x, y + plus_y + shift), 1)
else:
tone.line(canvas, (x, y + plus_y + shift),
import shades
canvas = shades.Canvas(1000, 907)
def units(n):
return n * (canvas.width / 205)
central_color = (200, 200, 200)
one = shades.NoiseGradient(
color=central_color,
noise_fields=[shades.NoiseField(scale=0.001) for i in range(3)])
two = shades.NoiseGradient(
color=central_color,
noise_fields=[shades.NoiseField(scale=0.001) for i in range(3)])
three = shades.NoiseGradient(
color=central_color,
noise_fields=[shades.NoiseField(scale=0.001) for i in range(3)])
fill = shades.NoiseGradient(
color=central_color,
noise_fields=[shades.NoiseField(scale=0.001) for i in range(3)])
fill.fill(canvas)
one.shape(canvas, [
(units(87), units(1)),
import shades
from random import randint, uniform
ms = randint(1, 9999)
ss = uniform(0.0001, 0.001)
canvas = shades.Canvas(1000, 1000)
gradient = shades.NoiseGradient(
color=(200, 200, 200),
color_variance=60,
noise_fields=[shades.NoiseField(scale=ss, seed=ms) for i in range(3)],
)
def random_mono_scale():
scale = uniform(0.0001, 0.001)
return (scale, scale, scale)
gradient.fill(canvas)
size_noise = shades.NoiseField(scale=0.02)
x_space_noise = shades.NoiseField(scale=0.02)
y_space_noise = shades.NoiseField(scale=0.002)
color_noise = shades.NoiseField(scale=0.02)
color_scales = [random_mono_scale() for i in range(6)]
x = 0
y = 0
t = randint(1, 9999)
scale = randint(3, 5)
import shades
from random import uniform, randint
noise_scale = uniform(0, 0.02)
spacing = randint(2, 6)
canvas = shades.Canvas(1000, 1000)
mono_field = shades.NoiseField(scale=0.002)
background = shades.NoiseGradient(
color=(240, 240, 240),
noise_fields=[mono_field for i in range(3)],
color_variance=40,
)
outline = shades.NoiseGradient(
(200, 200, 200),
noise_fields=[shades.NoiseField(scale=0.002) for i in range(3)],
)
tunnel_noise_x = shades.NoiseField(scale=noise_scale)
tunnel_noise_y = shades.NoiseField(scale=noise_scale)
background.fill(canvas)
def circle_and_fill(xy, radius):
for i in range(1, 50):
background.circle_outline(canvas, xy, radius + i, 1)
outline.circle_outline(canvas, xy, radius, 1)
import shades
import random
canvas = shades.Canvas(1000, 1000)
ink = shades.NoiseGradient(
color=(0, 20, 160),
noise_fields=[shades.NoiseField(scale=0.002) for i in range(3)],
warp_size=500,
warp_noise=[shades.NoiseField(scale=0.01),
shades.NoiseField(scale=0.01)])
def random_point():
x = random.randint(0, canvas.width)
y = random.randint(0, canvas.height)
return (x, y)
points = [random_point() for i in range(1000)]
for i in range(len(points) - 1):
ink.line(canvas, points[i], points[i + 1], 1)
canvas.show()
import shades
from PIL import ImageDraw
from PIL import ImageFont
canvas = shades.Canvas()
gradient = gradient = shades.NoiseGradient(
color=(50,150,250),
noise_fields = [shades.NoiseField(scale=0.002) for i in range(3)],
color_variance=70,
)
margin = 10
gradient.rectangle(
canvas,
(margin, margin),
canvas.width - margin*2,
canvas.height - margin*2,
)
draw = ImageDraw.Draw(canvas)
font_size = 90
free_sans = ImageFont.truetype('FreeSansBold.ttf', font_size)
haiku = [
"A logical",
"place, upon",
"this point",
"of time and",
"thus, the",
"conception",
]
haiku.reverse()
import shades
import random
canvas = shades.Canvas()
block = shades.BlockColor()
red = shades.NoiseGradient(
color = (241, 0, 0),
noise_fields = [shades.NoiseField(scale=0.005) for i in range(3)]
)
blue = shades.NoiseGradient(
color = (40, 13, 144),
noise_fields = [shades.NoiseField(scale=0.005) for i in range(3)]
)
yellow = shades.NoiseGradient(
color = (246, 225, 0),
noise_fields = [shades.NoiseField(scale=0.005) for i in range(3)]
)
mono_noise = shades.NoiseField(scale=0.005)
white = shades.NoiseGradient(
color = (240, 240, 240),
noise_fields = [mono_noise for i in range(3)]
)
gradient = shades.SwirlOfShades(
shades = [
(0, 0.2, white),
(0.2, 0.3, red),
import shades
import random
canvas = shades.Canvas(2000, 2000)
ink = shades.NoiseGradient(
color=(200, 200, 200),
color_fields=shades.noise_fields(scale=0.0002, channels=3),
color_variance=70,
warp_size=800,
warp_noise=shades.noise_fields(scale=0.002, channels=2),
)
def random_point():
x = random.randint(-800, canvas.width + 800)
y = random.randint(-800, canvas.height + 800)
return (x, y)
'''
points = [random_point() for i in range(5500)]
for i in range(len(points)-1):
ink.line(canvas, points[i], points[i+1], 1)
'''
for i in range(5000000):
ink.point(canvas, random_point())
canvas.show()
import shades
from random import randint, uniform
rs = randint(1, 9999)
gs = randint(1, 9999)
bs = randint(1, 9999)
canvas = shades.Canvas(1000, 1000)
gradient = shades.NoiseGradient(
color=(102, 150, 200),
color_variance=60,
noise_fields=[shades.NoiseField(scale=uniform(0.0001, 0.001)) for i in range(3)],
)
gradient.fill(canvas)
size_noise = shades.NoiseField(scale=0.02)
x_space_noise = shades.NoiseField(scale=0.02)
y_space_noise = shades.NoiseField(scale=0.002)
color_noise = shades.NoiseField(scale=0.02)
color_scales = [[uniform(0.0001, 0.001) for i in range(3)] for j in range(6)]
x = 0
y = 0
t = randint(1, 9999)
scale = randint(3,5)
scale_change_x = randint(2,4)
scale_change_y = randint(2, 4)
while y < canvas.height:
x = 0
import shades
import random
GRID_SIZE = 40
canvas = shades.Canvas()
shadow = shades.BlockColor((40, 40, 40))
gradient = shades.NoiseGradient((200, 200, 200))
for i in range(10):
# todo: add logic to check whether square already there
# add additional shapes
x = random.choice(range(0, canvas.width, GRID_SIZE))
y = random.choice(range(0, canvas.height, GRID_SIZE))
width = GRID_SIZE * random.randint(1, 5)
shadow.square(canvas, (x + 5, y + 5), width)
gradient.square(canvas, (x, y), width)
canvas.show()
import shades
from random import randint
canvas = shades.Canvas()
g_noise = [shades.NoiseField(scale=0.002) for i in range(3)]
def random_color():
r = randint(150, 250)
g = randint(150, 250)
b = randint(150, 250)
return (r, g, b)
shade_one = shades.NoiseGradient(color=random_color(), noise_fields=g_noise)
shade_two = shades.NoiseGradient(color=random_color(), noise_fields=g_noise)
shade_one.triangle(canvas, (0, 0), (0, canvas.height), (canvas.width, 0))
shade_two.triangle(canvas, (canvas.width, 0), (canvas.width, canvas.height),
(0, canvas.height))
canvas.show()
import shades
import random
canvas = shades.Canvas()
max_shape_height = random.randint(0, int(canvas.height/4))
for i in range(50):
height = random.randint(0, max_shape_height)
width = height / 3
color = random.choice([(0, 200, 200), (200, 0, 200), (200, 200, 0)])
shade = shades.NoiseGradient(
color=color,
color_variance=70,
noise_fields=[shades.NoiseField(scale=random.uniform(0, 0.01)) for i in range(3)],
transparency=random.uniform(0.2, 0.6),
)
shade.rectangle(
canvas=canvas,
xy=(random.randint(0, canvas.width), random.randint(0, canvas.height)),
width=width,
height=height,
)
canvas.show()
import shades
canvas = shades.Canvas()
shade = shades.NoiseGradient(
color = (253, 208, 41),
noise_fields = [shades.NoiseField(scale=0.002) for i in range(3)],
warp_size = 300,
warp_noise = (shades.NoiseField(scale=0.002),shades.NoiseField(scale=0.002))
)
for x in range(-300, canvas.width+300, 4):
shade.line(canvas, (x,-300), (x,canvas.height+300), 1)
for y in range(-300, canvas.height+300, 4):
shade.line(canvas, (-300,y), (canvas.height+300,y), 1)
canvas.show()
import shades
import random
canvas = shades.Canvas(2000, 2000)
uno_shade = shades.NoiseGradient((180, 180, 180),
color_fields=shades.noise_fields(scale=0.001))
dos_shade = shades.NoiseGradient((180, 180, 180),
color_fields=shades.noise_fields(scale=0.001))
uno_noise, dos_noise = shades.noise_fields(scale=0.005, channels=2)
uno_size, dos_size = shades.noise_fields(scale=0.005, channels=2)
uno = {'shade': uno_shade, 'noise': uno_noise, 'size': uno_size}
dos = {'shade': dos_shade, 'noise': dos_noise, 'size': dos_size}
for _ in range(10):
tone = random.choice([uno, dos])
start = random.randint(0, canvas.width)
plus = random.randint(100, 300)
space = random.randint(5, 20)
for y in range(300, canvas.height - 300, space):
for x in range(start, start + plus):
size = tone['size'].noise((x, y)) * 3
size += 1
size = int(size)
warp = tone['noise'].noise((x, y * 0.06))
warp -= 0.5
warp *= 200
tone['shade'].weighted_point(canvas, (x, y + warp), size)
canvas.show()
import shades
import random
canvas = shades.Canvas(700, 700)
shade = shades.NoiseGradient(
color=(240, 200, 200),
noise_fields=[shades.NoiseField(scale=0.002) for i in range(3)],
warp_size=100,
warp_noise=(
shades.NoiseField(scale=0.002),
shades.NoiseField(scale=0.002),
))
for i in range(random.randint(250, 350), random.randint(400, 550), 100):
shade.noise_fields = [shades.NoiseField(scale=0.002) for i in range(3)]
shade.rectangle(canvas, (-100, i), random.randint(500, 700), 100)
canvas.show()
import shades
canvas = shades.Canvas(1500, 1500)
noise_fields = [shades.NoiseField(scale=0.002) for i in range(3)]
block = shades.NoiseGradient((200, 200, 200), noise_fields=noise_fields)
fade = shades.NoiseGradient((220, 220, 220), noise_fields=noise_fields)
swirl = shades.SwirlOfShades(noise_field=shades.NoiseField(scale=0.005),
depth=1,
feedback=3,
shades=[
(0.8, 0.1, fade),
(0.1, 0.15, block),
(0.15, 0.17, fade),
(0.28, 0.3, fade),
(0.3, 0.35, block),
(0.35, 0.37, fade),
(0.48, 0.5, fade),
(0.5, 0.55, block),
(0.55, 0.57, fade),
(0.68, 0.7, fade),
(0.7, 0.75, block),
(0.75, 0.77, fade),
(0.88, 0.9, fade),
(0.9, 0.95, block),
(0.95, 0.97, fade),
])
swirl.fill(canvas)
import shades
from random import randint
from scipy.spatial import Delaunay
canvas = shades.Canvas()
ink = shades.NoiseGradient(
noise_fields=[shades.NoiseField(scale=0.002) for i in range(3)])
points = []
for x in range(0, canvas.width + 50, 20):
for y in range(0, canvas.height + 50, 20):
if randint(1, 3) == 1:
points.append((x, y))
# drawing triangles between points
for tri in Delaunay(points).simplices:
ink.color = [randint(180, 255) for i in range(3)]
ink.triangle(
canvas,
points[tri[0]],
points[tri[1]],
points[tri[2]],
)
canvas.show()
def random_point(margin):
x = randint(margin, canvas.width-margin)
y = randint(margin, canvas.height-margin)
return (x, y)
def nearby_point(point, distance):
x = point[0] + randint(-distance, distance)
y = point[1] + randint(-distance, distance)
return (x, y)
canvas = shades.Canvas()
circles = []
shade = shades.BlockColor()
gradient = shades.NoiseGradient(
color_variance=50,
noise_fields = [shades.NoiseField(scale=0.002) for i in range(3)],
)
colors = [(254, 208, 16), (21, 157, 73), (68, 76, 159)]
color_weights = [10, 4, 1]
for i in range(50000):
radius = randint(5, 7)
point = random_point(radius)
if not any([c for c in circles if shades.distance_between_points(c[0], point) <= radius + c[1] + 3]):
gradient.color = choices(colors, weights=color_weights)[0]
color = gradient.determine_shade(nearby_point(point, 300))
shade.color = color
shade.circle(canvas, point, radius)
circles.append((point, radius))
canvas.show()
import shades
from random import randint
from scipy.spatial import Delaunay
canvas = shades.Canvas(700, 700)
background = shades.NoiseGradient(
color=(0, 0, 50),
noise_fields=[shades.NoiseField(scale=0.002) for i in range(3)])
white = shades.BlockColor((255, 255, 255))
background.fill(canvas)
points = [(randint(0, canvas.width), randint(0, canvas.height))
for i in range(200)]
for point in points:
white.circle(canvas, point, randint(1, 1))
# drawing triangles between points
for tri in Delaunay(points).simplices:
if randint(1, 30) == 1:
white.triangle_outline(canvas, points[tri[0]], points[tri[1]],
points[tri[2]], 1)
canvas.show()
from random import randint
def random_point():
x = randint(0, canvas.width)
y = randint(0, canvas.height)
return (x, y)
def nearby_point(point):
x = point[0] + randint(-300, 300)
y = point[1] + randint(-300, 300)
return (x, y)
canvas = shades.Canvas(1000, 1000)
shade = shades.BlockColor()
gradient = shades.NoiseGradient(
color=(200,200,200),
color_variance=70,
)
for i in range(2):
x_offset = randint(-50, 50)
y_offset = randint(-50, 50)
gradient.noise_fields = [shades.NoiseField(scale=0.002) for i in range(3)]
points = [random_point() for i in range(500000)]
for point in points:
color = gradient.determine_shade(nearby_point(point))
shade.color = color
shade.point(canvas, (point[0] + x_offset, point[1] + y_offset))
canvas.show()
import shades
canvas = shades.Canvas()
shade = shades.NoiseGradient(
color=(200, 200, 200),
noise_fields=[shades.NoiseField(scale=0.002) for i in range(3)],
)
block = shades.BlockColor(
color=(240, 240, 240),
warp_size=150,
warp_noise=(shades.NoiseField(scale=0), shades.NoiseField(scale=0.008)),
)
shade.fill(canvas)
for y in range(-150, canvas.height + 150, 4):
block.line(canvas, (-150, y), (canvas.width + 150, y), 1)
canvas.show()
import shades
import random
warp_start = random.randint(30, 80)
warp_step = random.uniform(0.5, 5)
circle_step = random.randint(3, 6)
canvas = shades.Canvas(1000, 1000)
ink = shades.NoiseGradient(
color=(200, 200, 200),
noise_fields=[shades.NoiseField(scale=0.001) for i in range(3)],
color_variance=70,
warp_size=warp_start,
warp_noise=[shades.NoiseField(scale=0.003) for i in range(3)],
)
for i in range(1, canvas.width, circle_step):
ink.warp_size += warp_step
ink.circle_outline(canvas, (canvas.width / 2, canvas.height / 2), i, 1)
canvas.show()
