Circlepusher: Making generative art in python

What is generative art and why am I interested in it?

In general generative art is defined as art that has been (at least in some part) created by using an autonomous system. I think of it as art that is created by some system, but the artist (not the system although some may argue that the system is the true artist) doesn't know exactly how it will turn out. While the artist can tweak some parts of the system (usually the inputs) they do not have full control of the generation of the artwork.

I recently discovered generative art after reading an excellent article by Anders Hoff, titled On Generative Algorithms. I found it to be a very interesting read, well worth your time, and it inspired me to make my own generative algorithms. In particular the first example, Hyphae, interested me. I thought, hey I bet I can do that in a couple lines of python!

Enter Circlepusher

The goal is to push some circles around on a canvas that don't intersect with each other and randomly split into smaller circles to be pushed. Let's start by making those circles, we need something to store a location, a radius, and some random angle

import random


class Circle:
    def __init__(self, radius, location):
        """
        :param radius: radius of circle in pixels
        :param location: two tuple of x,y
        """
        self.radius = radius
        self.location = location
        self.angle = random.randint(0, 360)

    @property
    def x(self):
        return self.location[0]

    @property
    def y(self):
        return self.location[1]

What good's a circle if you can't see it (and is it even really a circle at all)? There's probably other ways to draw circles, but I'm going to use PIL(low) because it was pretty simple. Also I'm going to use some globals because I don't care if this code is pretty, I want it to be easy to hack.

import random

from PIL import Image, ImageDraw

image = Image.new('L', (500, 500), 'white')
image_draw = ImageDraw.Draw(image)


class Circle:
    def __init__(self, radius, location):
        """
        :param radius: radius of circle in pixels
        :param location: two tuple of x,y
        """
        self.radius = radius
        self.location = location
        self.angle = random.randint(0, 360)

    def draw(self):
        image_draw.ellipse((self.x - self.radius,
                            self.y - self.radius,
                            self.x + self.radius,
                            self.y + self.radius), fill='black')

circle = Circle(10, (250, 250))
circle.draw()
image.show()

Now we have a nice big black circle in the middle of our canvas, here's some docs on PIL.Image.new (the L we specify tells Pillow that this will be a grayscale image, see PIL Modes if you want to learn more).

Now it's time to push it (push it real good)!

import random

from PIL import Image, ImageDraw
...

Class Circle:

...

    def push(self):
        # Let's step by 1/4 of the radius each time
        step = self.radius / 4
        rad_angle = math.radians(self.angle)
        self.location = (self.x + step*math.cos(rad_angle),
                         self.y + step*math.sin(rad_angle))

circle = Circle(10, (250, 250))
for _ in range(100):
    circle.draw()
    circle.push()
image.show()

Woo! We have a single clock hand, not too impressive huh? However if we continue to increase the number of iterations we'll soon run off the edge of the canvas, let's prevent that by adding a check to the push function

import random

import math
from PIL import Image, ImageDraw

image_bounds = (500, 500)
image = Image.new('L', image_bounds, 'white')
image_draw = ImageDraw.Draw(image)


class Circle:
    def __init__(self, radius, location):
        """
        :param radius: radius of circle in pixels
        :param location: two tuple of x,y
        """
        self.radius = radius
        self.location = location
        self.angle = random.randint(0, 360)

    def draw(self):
        image_draw.ellipse((self.x - self.radius,
                            self.y - self.radius,
                            self.x + self.radius,
                            self.y + self.radius), fill='black')

    def push(self):
        # Let's step by 1/4 of the radius each time
        step = self.radius / 4
        rad_angle = math.radians(self.angle)
        next_step = (self.x + step*math.cos(rad_angle),
                     self.y + step*math.sin(rad_angle))
        if self.within_bounds(next_step):
            self.location = next_step

    @staticmethod
    def within_bounds(location):
        if location[0] < 0 or location[0] > image_bounds[0] or location[1] < 0 or location[1] > image_bounds[1]:
            return False
        return True
...

This doesn't take into account the radius of the circle being pushed, it only checks it's center. Why should we limit ourselves to 2 circles? Let's make 10!

for _ in range(10):
    circle = Circle(10, (250, 250))
    for __ in range(100):
        circle.draw()
        circle.push()

Well... it is a thing, but not a very good thing. Let's make it so that they don't step on each other. I'll start by adding the concept of deactivating a circle, if it bumps into another circle, let's not keep trying to push it. Note that the method of detecting "collision" is pretty "stupid" since I'm just checking a single pixel ahead of us, we could still collide at any of the other pixels we're about to paint. Next let's make sure we don't step over the edge of the canvas. Finally let's add a little spin to the movement of our circles, a curve which will be added to the angle at each step.

import random

import math
from PIL import Image, ImageDraw

image_bounds = (500, 500)
image = Image.new('L', image_bounds, 'white')
image_draw = ImageDraw.Draw(image)


class Circle:
    def __init__(self, radius, location):
        """
        :param radius: radius of circle in pixels
        :param location: two tuple of x,y
        """
        self.radius = radius
        self.location = location
        self.angle = random.randint(0, 360)
        self.curve = random.randint(-45, 45)/100
        self.active = True

    @property
    def x(self):
        return self.location[0]

    @property
    def y(self):
        return self.location[1]

    def draw(self):
        if not self.active:
            return
        image_draw.ellipse((self.x - self.radius,
                            self.y - self.radius,
                            self.x + self.radius,
                            self.y + self.radius), fill='black')

    def push(self):
        if not self.active:
            return
        # Let's step by 1/4 of the radius each time
        step = self.radius / 4
        rad_angle = math.radians(self.angle)
        next_step = (self.x + step*math.cos(rad_angle),
                     self.y + step*math.sin(rad_angle))
        # Stepping by 1/4 of the radius will put us still inside our current radius, so let's look a bit further ahead
        big_step = (self.x + self.radius*2*math.cos(rad_angle),
                    self.y + self.radius*2*math.sin(rad_angle))
        if self.within_bounds(next_step) and self.free_spot(big_step):
            self.location = next_step
        else:
            self.active = False
            if self in circles:
                circles.remove(self)

        self.angle = (self.angle + self.curve) % 360

    @staticmethod
    def within_bounds(location):
        if location[0] < 0 or location[0] > image_bounds[0] or location[1] < 0 or location[1] > image_bounds[1]:
            return False
        return True

    def free_spot(self, spot):
        # Simply check the canvas to see if the passed spot is white
        return self.within_bounds(spot) and image.getpixel(spot) == 255

for _ in range(10):
    circle = Circle(10, (250, 250))
    for __ in range(1000):
        circle.draw()
        circle.push()
image.show()

Now we have lines that curve beautifully, don't intersect with each other and stop without going over the edge of the canvas. Finally we have something worth tinkering with.

Making Babies

Time to mutate! Let's create some smaller versions of our tentacles that randomly come off of our main "branches". Babies should probably be smaller then their parent(s?) so let's make their radius 75% of their parent. While we're at it let's randomize the starting location of our circles.

import random

import math
from PIL import Image, ImageDraw

image_bounds = (500, 500)
image = Image.new('L', image_bounds, 'white')
image_draw = ImageDraw.Draw(image)
circles = []

...

class Circle:

        ...
    def push(self):
        if not self.active:
            return

        if self.should_make_baby():
            circles.append(self.make_baby())

        # Let's step by 1/4 of the radius each time
        step = self.radius / 4
        rad_angle = math.radians(self.angle)
        next_step = (self.x + step*math.cos(rad_angle),
                     self.y + step*math.sin(rad_angle))
        # Stepping by 1/4 of the radius will put us still inside our current radius, so let's look a bit further ahead
        big_step = (self.x + self.radius*2*math.cos(rad_angle),
                    self.y + self.radius*2*math.sin(rad_angle))
        if self.within_bounds(next_step) and self.free_spot(big_step):
            self.location = next_step
        else:
            self.active = False
            if self in circles:
                circles.remove(self)

        self.angle = (self.angle + self.curve) % 360

    ...

    @staticmethod
    def should_make_baby():
        # 1/50 chance to make a baby
        return not random.randint(0, 20)

    def make_baby(self):
        return Circle(self.radius*.75, self.location)


for _ in range(10):
    circles.append(Circle(10, (random.randint(0, image_bounds[0]),
                               random.randint(0, image_bounds[1]))))

for _ in range(1000):
    for circle in circles:
        circle.draw()
        circle.push()

image.show()

Not the prettiest thing, but nice and noisey.

To Be Continued...