def nearby_point(point, distance):
x = point[0] + randint(-distance, distance)
y = point[1] + randint(-distance, distance)
while shades.distance_between_points(point, (x, y)) > distance:
x = point[0] + randint(-distance, distance)
y = point[1] + randint(-distance, distance)
return (x, y)
canvas = shades.Canvas(4000, 4000)
background_shade = shades.BlockColor((240, 240, 240))
foreground = shades.BlockColor(
color=(41, 104, 136),
warp_size=50,
warp_noise=[shades.NoiseField(scale=0.02),
shades.NoiseField(scale=0.001)],
)
steps = 25
walk_distance = 10
wackiness = 50
for i in range(1, steps):
y = i / steps * canvas.height
start = (0, y)
end = (canvas.width, y)
last_point = start
while last_point[0] < end[0]:
point = (last_point[0] + walk_distance, y)
point = nearby_point(point, wackiness)
while shades.distance_between_points(point, last_point) < 1:
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(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
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
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 numpy as np
CANVAS = shades.Canvas(1000, 1000)
class Cloud(shades.Shade):
def __init__(self, color, noise=shades.NoiseField(), air=0.3):
super().__init__(color)
self.cloud_noise = noise
self.air = air
def determine_shade(self, xy_coords):
color = CANVAS.getpixel(xy_coords)
noise = self.cloud_noise.noise(xy_coords)
noise = max(noise, 0)
return shades.color_clamp([
np.average([color[i], self.color[i]],
weights=[0.5, noise * self.air]) for i in range(3)
])
colors = [(250, 0, 0), (0, 250, 0), (0, 0, 250)]
np.random.shuffle(colors)
for color in colors:
tone = Cloud(color, shades.NoiseField(scale=0.001))
tone.fill(CANVAS)
CANVAS.show()
import shades
from handy_stuff import palletes
import random
pallete = random.choice(palletes)
canvas = shades.Canvas()
tones = []
i = 0
while i < 1:
add_to = random.uniform(0.0001, 0.0005)
tones.append((
i,
i + add_to,
shades.BlockColor(random.choice(pallete)),
))
i += add_to
swirl = shades.SwirlOfShades(
shades=tones,
swirl_field=shades.NoiseField(scale=0.002),
depth=1,
)
swirl.fill(canvas)
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
import random
canvas = shades.Canvas(2000, 2000)
shade = shades.NoiseGradient((180, 180, 180),
color_fields=shades.noise_fields(scale=0.001))
noise = shades.NoiseField(scale=0.005)
shift = random.uniform(0.4, 0.6)
start = random.randint(0, canvas.width * 0.3)
plus = random.randint(canvas.width * 0.33, canvas.width * 0.75)
space = random.randint(2, 7)
keep = False
for y in range(-canvas.height, canvas.height + 400, space):
for i, x in enumerate(range(-400, canvas.width + 400)):
if not keep:
keep = random.random() > 0.99
else:
keep = random.random() > 0.01
if keep:
warp = noise.noise((x, y * 0.06))
warp -= 0.5
warp *= 200
shade.point(canvas, (x, y + warp + (shift * i)))
canvas.show()
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
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
canvas = shades.Canvas()
black = shades.BlockColor((20, 20, 20))
red = shades.BlockColor((255, 20, 0))
blue = shades.BlockColor((0, 139, 200))
swirl = shades.SwirlOfShades(shades=[(0.25, 0.3, black), (0.3, 0.4, red),
(0.4, 0.45, black), (0.55, 0.6, black),
(0.6, 0.8, blue), (0.8, 0.85, red),
(0.85, 0.9, black)],
noise_field=shades.NoiseField(scale=0.006),
feedback=2)
swirl.fill(canvas)
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
from handy_stuff import palletes
pallete = random.choice(palletes)
canvas = shades.Canvas(3000, 4000, random.choice(pallete))
x_field = shades.NoiseField(scale=random.uniform(0.003, 0.008), )
y_field = shades.NoiseField(scale=random.uniform(0.003, 0.008), )
ink = shades.BlockColor()
class Walker():
"""
Class to move based on flow field, 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
ink.color = color
def draw(self):
ink.point(canvas, (int(self.xy[0]), int(self.xy[1])))
def move(self):
x_vect = x_field.noise((
int(self.xy[0]),
int(self.xy[1]),
))
y_vect = y_field.noise((
int(self.xy[0]),
import shades
canvas = shades.Canvas()
warp_size = 50
warp = shades.BlockColor(
warp_size=warp_size,
warp_noise=[shades.NoiseField(scale=0.1),
shades.NoiseField(scale=0)],
)
ink = shades.BlockColor()
noise = shades.NoiseField()
for y in range(-warp_size, canvas.height + warp_size, 10):
for x in range(-warp_size, canvas.width + warp_size):
size = noise.noise((x, y)) * 3
if size > 0:
xy = warp.adjust_point((x, y))
ink.circle(canvas, xy, size)
canvas.show()
import shades
from random import randint
canvas = shades.Canvas(1000, 1000, (220, 230, 229))
block = shades.BlockColor((229, 211, 96))
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)
colors = [
(189, 213, 215),
(67, 99, 110),
(253, 243, 218),
(103, 151, 165),
(255, 193, 178),
]
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
while x < canvas.width:
block.circle(canvas, (x, y), size_noise.noise((t, 1)) * scale)
x += x_space_noise.noise((t, 1)) * scale * scale_change_x
t += 1
c_val = color_noise.noise((t, 1))
import shades
canvas = shades.Canvas()
ink = shades.BlockColor(color=(0,255, 255), transparency=0.6, warp_noise=[shades.NoiseField(0.002) for i in range(2)], warp_size=30)
ink2 = shades.BlockColor(color=(255, 0, 255), transparency=0.6, warp_noise=[shades.NoiseField(0.002) for i in range(2)], warp_size=30)
ink3 = shades.BlockColor(color=(255, 255, 0), transparency=0.6, warp_noise=[shades.NoiseField(0.002) for i in range(2)], warp_size=30)
ink4 = shades.BlockColor(color=(0,255, 255), transparency=0.6, warp_noise=[shades.NoiseField(0.002) for i in range(2)], warp_size=30)
ink5 = shades.BlockColor(color=(255, 0, 255), transparency=0.6, warp_noise=[shades.NoiseField(0.002) for i in range(2)], warp_size=30)
ink6 = shades.BlockColor(color=(255, 255, 0), transparency=0.6, warp_noise=[shades.NoiseField(0.002) for i in range(2)], warp_size=30)
for x in range(-30, canvas.width+30, 5):
for y in range(-30, canvas.height+30, 5):
ink.line(canvas, (x,y), (x, y+3))
ink2.line(canvas, (x,y), (x, y+3))
ink3.line(canvas, (x,y), (x, y+3))
ink4.line(canvas, (x,y), (x, y+3))
ink5.line(canvas, (x,y), (x, y+3))
ink6.line(canvas, (x,y), (x, y+3))
canvas.show()
def nearby_point(point, distance):
x = point[0] + randint(-distance, distance)
y = point[1] + randint(-distance, distance)
while shades.distance_between_points(point, (x, y)) > distance:
x = point[0] + randint(-distance, distance)
y = point[1] + randint(-distance, distance)
return (x, y)
def blueish():
blue = (87, 141, 209)
blueish = [i + randint(-20, 20) for i in blue]
return tuple(blueish)
canvas = shades.Canvas(1000, 1000)
shade = shades.BlockColor(
color=(87, 141, 209),
transparency=0.95,
warp_size=20,
warp_noise=[shades.NoiseField(scale=0.002) for i in range(2)])
center = (int(canvas.width / 2), int(canvas.height / 2))
for i in range(15):
off_center = nearby_point(center, 100)
shade.circle(canvas, off_center, 300)
canvas.show()
import shades
import random
canvas = shades.Canvas(2400 * 2, 1500 * 2, (20, 20, 20))
class RandomFill(shades.Shade):
def determine_shade(self, xy):
if random.random() < self.chance:
return (200, 200, 200)
tone = RandomFill(
warp_size=500,
warp_noise=[shades.NoiseField(scale=0),
shades.NoiseField(scale=0.00125)],
)
for y in range(0, canvas.height + 500, 10 * 2):
tone.chance = (y**2 / 10000) / 500 / 2
for i in range(0, 3):
tone.line(canvas, (-500, y + i), (canvas.width, y + i), 1)
canvas.show()
import shades
from random import randint
canvas = shades.Canvas(1000, 1000)
shade = shades.BlockColor(
warp_size=140,
warp_noise=[shades.NoiseField(scale=0.003) for i in range(2)])
gradient = shades.NoiseGradient(
color=(200, 200, 200),
noise_fields=[shades.NoiseField(scale=0.002) for i in range(3)])
def random_point():
x = randint(-140, canvas.width + 140)
y = randint(-140, canvas.height + 340)
return (x, y)
def nearby_point(point):
x = point[0] + randint(-300, 300)
y = point[1] + randint(-300, 300)
return (x, y)
points = [random_point() for i in range(5000)]
for point in points:
color = gradient.determine_shade(nearby_point(point))
shade.color = color
shade.line(canvas, point, (point[0], point[1] + 200), 2)
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)
def __init__(self, color, noise=shades.NoiseField(), air=0.3):
super().__init__(color)
self.cloud_noise = noise
self.air = air
import shades
canvas = shades.Canvas()
shade = shades.DomainWarpGradient(
color=(260, 260, 260),
color_variance=60,
noise_fields=[
shades.NoiseField(scale=0.002),
shades.NoiseField(scale=0.003),
shades.NoiseField(scale=0.005)
],
depth=2,
feedback=2.4,
)
shade.fill(canvas)
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
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)
