Here’s a bot for shoebot I made a while back that uses perlin noise to generate some nice circles.

You’ll need shoebot and the lib “noise” installed into your environment for it to work;

# pip install noise

Then to run;

sbot -w perlin-circlescape1.bot

Here’s a video of them in action -

See below the break for the code -

import noise

size(1000,1000)
speed(60)

colormode(HSB)

def setup():
    global origx, origy
    origx = 0
    origy = 0    

rows = 8
cols = 9
gap = 100

def draw():
    global origx, origy, gap

    # black background
    background(0)

    # start from 100,100
    translate(100,100)
    # and draw the blocks
    mx = float(1.0 / WIDTH) * (-MOUSEX - (-WIDTH / 2))
    my = float(1.0 / HEIGHT) * (-MOUSEY - (-HEIGHT / 2))
    
    origx += (mx / 8.0)
    origy += (my / 8.0)
    for gx,gy in grid(rows,cols,1,1):
        # height of each block is determined by x,y coordinates
        n = (noise.pnoise2(float(origx + (gx / 10.0)), float(origy + (gy / 10.0)), 2) / cols)
        diam = 50 + (n * 600.0)
        s = (n * 10.0)
        fill(0.1, 1.0 - s, 1)
        x = gx * gap
        y = gy * gap
        oval(x - diam / 2, y - diam / 2, diam, diam)

Particles, generally means – a lot of things moving around (the particles) and a way to generate them, an “emitter”

Here we’re going to take the code from the previous two parts and add a couple of things to make a basic particle system.
Note – shoebot, isn’t the fastest; but we do get nice looking results.

Here’s a video of our arrows as particles (arrowsplosion!):

So the parts needed are the bits that move ‘particles’, this is made by extending the Moveable class to give it an hp, some functions to manage the list of particles (when their hp goes below 0 they are removed from the list).

class Particle(Moveable):
    def __init__(self, hp = 250, **kwargs):
        Moveable.__init__(self, draw_func = self.draw_func, **kwargs)
        self.hp = hp

    def update(self):
        super(Particle, self).update()
        self.hp -=1
        return self.hp > 0

    def draw_func(self):
        a = 1.0
        if 0 < self.hp < 250:
           a = self.hp / 250.0
        arrow(0, 0, 80, fill=(1, 0, 0, a))

The last part is particle creation, we create a function random_emitter, this just adds a particle to the list of particles.

def random_emitter(particles):
    if random() > 0.1:
        p = Particle(
            velocity = random() * 2.0,
            angle = random() * 360,
            controller = inertia_controller)
        particles.append(p)

the draw function is modified to call these:

def update_particles(particles):
    '''
    Update particles
    
    return: list of particles to update
    '''
    part = []
    for p in particles:
        if p.update():
            part.append(p)
    return part

def draw():
    global particles

    random_emitter(particles)
    particles = update_particles(particles)

    for p in particles:
        p.draw()

Complete listing.

from random import random

from planar.py import Vec2, Affine
from collections import namedtuple


class Moveable(object):
    """
    Moveable object.

    Controller functions manage the movement and are called on 'update'
    """
    def __init__(self, pos = None, velocity = None, angle = None, controller = None, controllers = None, draw_func = None):
        self.pos = pos or Vec2(WIDTH / 2, HEIGHT / 2)
        self.velocity = velocity or 0.0
        self.angle = angle or 0
        self.draw_func = draw_func
        if controller:
            self.controllers = [ controller ]
        else:
            self.controllers = []
        if controllers:
            self.controllers.extend(controllers)

    def update(self):
        """
        Call all the controllers to update coordinates.
        
        Angles are always wrapped to 360 degrees.
        """
        pos, angle, velocity = self.pos, self.angle, self.velocity
        for controller in self.controllers:
            pos, angle, velocity = controller(pos, angle % 360, velocity)
        self.pos, self.angle, self.velocity = pos, angle % 360, velocity
        self.pos += Vec2.polar(angle = angle, length = velocity)

    def draw(self):
        push()
        translate(self.pos.x, self.pos.y)
        rotate(-self.angle) # nodebox1/shoebot rotation is anticlockwise
        self.draw_func()
        pop()



class Particle(Moveable):
    def __init__(self, hp = 250, **kwargs):
        Moveable.__init__(self, draw_func = self.draw_func, **kwargs)
        self.hp = hp

    def update(self):
        super(Particle, self).update()
        self.hp -=1
        return self.hp > 0

    def draw_func(self):
        a = 1.0
        if 0 < self.hp < 250:
           a = self.hp / 250.0
        arrow(0, 0, 80, fill=(1, 0, 0, a))



def key_controller(pos, angle, velocity):
    if keydown:
        if keycode == KEY_UP:
            velocity += 0.2
        elif keycode == KEY_DOWN:
            velocity -= 0.2
        elif keycode == KEY_LEFT:
            angle -= 5
        elif keycode == KEY_RIGHT:
            angle += 5
        elif keycode == KEY_SPACE:
            velocity *= 0.9
        elif keycode == KEY_RETURN:
            pos = Vec2(WIDTH / 2, HEIGHT / 2)
            velocity = 0.0
            angle = 0
    return pos, angle, velocity


def inertia_controller(pos, angle, velocity):
    return pos, angle, velocity * 0.99


def bounds_controller(pos, angle, velocity):
    if pos.x < 10 or pos.x > WIDTH:
        angle = 180 - angle
    if pos.y < 10 or pos.y > HEIGHT - 10:
        angle = - angle
    return pos, angle, velocity



def random_emitter(particles):
    if random() > 0.1:
        p = Particle(
            velocity = random() * 2.0,
            angle = random() * 360,
            controller = inertia_controller)
        particles.append(p)


def update_particles(particles):
    '''
    Update particles
    
    return: list of particles to update
    '''
    part = []
    for p in particles:
        if p.update():
            part.append(p)
    return part



def setup():
    global particles
    speed(60)
    size(800, 600)
    transform(mode=CENTER)

    particles = []
    

def draw():
    global particles

    random_emitter(particles)
    particles = update_particles(particles)

    for p in particles:
        p.draw()

This will make the code a little more complex, but as usual it makes things simpler later on.

Note:

This python code runs in shoebot, planar.py is used to handle coordinates

https://github.com/shoebot

planar.py

At the end we’ll have two arrows, a blue one controlled with the keyboard and a pink one that moves on it’s own:

At the moment all movement behaviour is in the draw function (see below) – we’re going to move all the movement behaviour into seperate functions.

Current draw function:

def key_controller(pos, angle, velocity):
    if keydown:
        if keycode == KEY_UP:
            velocity += 0.2
        elif keycode == KEY_DOWN:
            velocity -= 0.2
        elif keycode == KEY_LEFT:
            angle -= 5
        elif keycode == KEY_RIGHT:
            angle += 5
        elif keycode == KEY_SPACE:
            velocity *= 0.9
        elif keycode == KEY_RETURN:
            pos = Vec2(WIDTH / 2, HEIGHT / 2)
            velocity = 0.0
            angle = 0
    return pos, angle, velocity


def inertia_controller(pos, angle, velocity):
    return pos, angle, velocity * 0.99


def bounds_controller(pos, angle, velocity):
    if pos.x < 10 or pos.x > WIDTH:
        angle = 180 - angle
    if pos.y < 10 or pos.y > HEIGHT - 10:
        angle = - angle
    return pos, angle, velocity

Then make a class to manage these, along with initial position + velocity – along with a custom drawing function:

class Moveable(object):
    """
    Moveable object.

    Controller functions manage the movement and are called on 'update'
    """
    def __init__(self, pos = None, velocity = None, angle = None, controller = None, controllers = None, draw_func = None):
        self.pos = pos or Vec2(WIDTH / 2, HEIGHT / 2)
        self.velocity = velocity or 0.0
        self.angle = angle or 0
        self.draw_func = draw_func
        if controller:
            self.controllers = [ controller ]
        else:
            self.controllers = []
        if controllers:
            self.controllers.extend(controllers)

    def update(self):
        """
        Call all the controllers to update coordinates.
        
        Angles are always wrapped to 360 degrees.
        """
        pos, angle, velocity = self.pos, self.angle, self.velocity
        for controller in self.controllers:
            pos, angle, velocity = controller(pos, angle % 360, velocity)
        self.pos, self.angle, self.velocity = pos, angle % 360, velocity
        self.pos += Vec2.polar(angle = angle, length = velocity)

    def draw(self):
        push()
        translate(self.pos.x, self.pos.y)
        rotate(-self.angle) # nodebox1/shoebot rotation is anticlockwise
        self.draw_func()
        pop()

Since I just want the draw function to draw two different colour arrows, a closure is used to generate these functions:

def draw_arrow(fill=None):
    def do_draw():
        arrow(40, 40, 80, fill=fill)
    return do_draw

By passing the output of draw_func = draw_arrow(fill=(1,0,0)) a red arrow is will be drawn every time ‘draw_func’ is called.

Using all of the above, the setup() function to create the two arrows is fairly straightforward:

def setup():
    global auto_arrow, driven_arrow
    speed(60)
    size(800, 600)
    transform(mode=CENTER)
    driven_arrow = Moveable(
        controllers = [key_controller, bounds_controller, inertia_controller], 
        draw_func = draw_arrow(fill=(0, 0, 1, 0.2)))

    auto_arrow = Moveable(
        velocity = 5.0,
        angle = 45,
        controller = bounds_controller,
        draw_func = draw_arrow(fill=(1, 0, 0, 0.2)))

driven_arrow and auto_arrow are both instances of ‘Moveable’, they have different behaviours set by their controller functions and their draw functions will draw them in a transparent red and blue colours.

The final draw function, simply calls ‘update’ and ‘draw’ on auto_arrow and driven_arrow:

def draw():
    global auto_arrow, driven_arrow

    driven_arrow.update()
    auto_arrow.update()

    driven_arrow.draw()
    auto_arrow.draw()

Using this system it’s easy to add custom behaviours (controllers) and drawing functions.

This can be extended into a simple particle system – Particle is just a Moveable with a lifecycle and a factory function (emitter) needs to be added to create the particles, along with a little management code.

Next time – extending this into a simple particle system.

Full listing:

# In this version of the file the concept of a controller is introduced.
#
# A controller takes the position, angle and velocity of the thing to be moved
# and returns a new position, angle and velocity.
#
# The machinery to manage this is wrapper up in the Movable class

from planar.py import Vec2, Affine
from collections import namedtuple


class Moveable(object):
    """
    Moveable object.

    Controller functions manage the movement and are called on 'update'
    """
    def __init__(self, pos = None, velocity = None, angle = None, controller = None, controllers = None, draw_func = None):
        self.pos = pos or Vec2(WIDTH / 2, HEIGHT / 2)
        self.velocity = velocity or 0.0
        self.angle = angle or 0
        self.draw_func = draw_func
        if controller:
            self.controllers = [ controller ]
        else:
            self.controllers = []
        if controllers:
            self.controllers.extend(controllers)

    def update(self):
        """
        Call all the controllers to update coordinates.
        
        Angles are always wrapped to 360 degrees.
        """
        pos, angle, velocity = self.pos, self.angle, self.velocity
        for controller in self.controllers:
            pos, angle, velocity = controller(pos, angle % 360, velocity)
        self.pos, self.angle, self.velocity = pos, angle % 360, velocity
        self.pos += Vec2.polar(angle = angle, length = velocity)

    def draw(self):
        push()
        translate(self.pos.x, self.pos.y)
        rotate(-self.angle) # nodebox1/shoebot rotation is anticlockwise
        self.draw_func()
        pop()



def key_controller(pos, angle, velocity):
    if keydown:
        if keycode == KEY_UP:
            velocity += 0.2
        elif keycode == KEY_DOWN:
            velocity -= 0.2
        elif keycode == KEY_LEFT:
            angle -= 5
        elif keycode == KEY_RIGHT:
            angle += 5
        elif keycode == KEY_SPACE:
            velocity *= 0.9
        elif keycode == KEY_RETURN:
            pos = Vec2(WIDTH / 2, HEIGHT / 2)
            velocity = 0.0
            angle = 0
    return pos, angle, velocity


def inertia_controller(pos, angle, velocity):
    return pos, angle, velocity * 0.99


def bounds_controller(pos, angle, velocity):
    if pos.x < 10 or pos.x > WIDTH:
        angle = 180 - angle
    if pos.y < 10 or pos.y > HEIGHT - 10:
        angle = - angle
    return pos, angle, velocity




def draw_arrow(fill=None):
    def do_draw():
        arrow(40, 40, 80, fill=fill)
    return do_draw


def setup():
    global auto_arrow, driven_arrow
    speed(60)
    size(800, 600)
    transform(mode=CENTER)
    driven_arrow = Moveable(
        controllers = [key_controller, bounds_controller, inertia_controller], 
        draw_func = draw_arrow(fill=(0, 0, 1, 0.2)))

    auto_arrow = Moveable(
        velocity = 5.0,
        angle = 45,
        controller = bounds_controller,
        draw_func = draw_arrow(fill=(1, 0, 0, 0.2)))


def draw():
    global auto_arrow, driven_arrow

    driven_arrow.update()
    auto_arrow.update()

    driven_arrow.draw()
    auto_arrow.draw()

Running in shoebot:

sbot -w arrow_controlled.bot

This uses polar coordinates to decide the direction and velocity of an arrow on the screen.

Polar coordinates mean we can give an object a sense of ‘forward’, ‘back’, ‘left’ and ‘right’

The code below works on the current version of shoebot

https://github.com/shoebot/shoebot.git

With planar.py to handle the directions and velocity

https://pypi.python.org/pypi/planar

There’s some code to handle edges (the arrow will bounce off the edges). Also, since the nodebox grammar which we are using does anticlockwise rotations we need to handle this.

# Use cursor keys to move arrow
# space is a brake, return resets

from planar.py import Vec2, Affine

def setup():
    global pos, angle, velocity
    speed(60)
    size(800, 600)
    pos = Vec2(WIDTH / 2, HEIGHT / 2)
    velocity = 0.0
    angle = 0

def draw():
    global pos, angle, velocity
    transform(mode=CENTER)
    if keydown:
        if keycode == KEY_UP:
            velocity += 0.2
        elif keycode == KEY_DOWN:
            velocity -= 0.2
        elif keycode == KEY_LEFT:
            angle -= 5
        elif keycode == KEY_RIGHT:
            angle += 5
        elif keycode == KEY_SPACE:
            velocity *= 0.9
        elif keycode == KEY_RETURN:
            pos = Vec2(WIDTH / 2, HEIGHT / 2)
            velocity = 0.0
            angle = 0
    else:
        velocity *= 0.99

    angle = angle % 360
    pos += Vec2.polar(angle = angle, length = velocity)

    if pos.x < 10 or pos.x > WIDTH:
        angle = 180 - angle
    if pos.y < 10 or pos.y > HEIGHT - 10:
        angle = - angle

    translate(pos.x, pos.y)
    rotate(-angle) # nodebox1/shoebot rotation is anticlockwise

    arrow(40, 40, 80, fill=(0, 0, 1, 0.2))

Running the code in shoebot:

sbot -w arrow_drive.bot.

This has basic movement, + intertia, it can be used for a number of things (e.g. 2d games)

Wanting to get some other files noticed, I added some in the __init__.py of my app, so it looked like this:

try:
    from django.conf import settings

    if settings.DEBUG:
        import forms, util, tests
except:
    pass

This seemed to be working fine until I swapped to postgres and tried to do syncdb .. and reset, uh oh !

Postgres said (names changed to protect the innocent):

2012-05-10 09:47:57 BST STATEMENT:
                    SELECT c.relname
                    FROM pg_catalog.pg_class c
                    LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
                    WHERE c.relkind IN ('r', 'v', '')
                        AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
                        AND pg_catalog.pg_table_is_visible(c.oid)
2012-05-10 09:47:57 BST LOG:  could not receive data from client: Connection reset by peer
2012-05-10 09:47:57 BST LOG:  unexpected EOF on client connection
2012-05-10 09:49:14 BST ERROR:  relation "sandwich_maker_filling" does not exist at character 72
2012-05-10 09:49:14 BST STATEMENT:  SELECT "sandwich_maker_filling"."id", "sandwich_maker_filling"."name" FROM "sandwich_maker_filling"
2012-05-10 09:49:14 BST ERROR:  current transaction is aborted, commands ignored until end of transaction block

And django wasn’t too happy either:

Traceback (most recent call last):
  File "manage.py", line 10, in <module>
    execute_from_command_line(sys.argv)
  File "/home/stu/.virtualenvs/the_app/local/lib/python2.7/site-packages/django/core/management/__init__.py", line 443, in execute_from_command_line
    utility.execute()
  File "/home/stu/.virtualenvs/the_app/local/lib/python2.7/site-packages/django/core/management/__init__.py", line 382, in execute
    self.fetch_command(subcommand).run_from_argv(self.argv)
  File "/home/stu/.virtualenvs/the_app/local/lib/python2.7/site-packages/django/core/management/base.py", line 196, in run_from_argv
    self.execute(*args, **options.__dict__)
  File "/home/stu/.virtualenvs/the_app/local/lib/python2.7/site-packages/django/core/management/base.py", line 232, in execute
    output = self.handle(*args, **options)
  File "/home/stu/.virtualenvs/the_app/local/lib/python2.7/site-packages/django/core/management/base.py", line 371, in handle
    return self.handle_noargs(**options)
  File "/home/stu/.virtualenvs/the_app/local/lib/python2.7/site-packages/django/core/management/commands/syncdb.py", line 60, in handle_noargs
    tables = connection.introspection.table_names()
  File "/home/stu/.virtualenvs/the_app/local/lib/python2.7/site-packages/django/db/backends/__init__.py", line 896, in table_names
    return self.get_table_list(cursor)
  File "/home/stu/.virtualenvs/the_app/local/lib/python2.7/site-packages/django/db/backends/postgresql_psycopg2/introspection.py", line 33, in get_table_list
    AND pg_catalog.pg_table_is_visible(c.oid)""")
  File "/home/stu/.virtualenvs/the_app/local/lib/python2.7/site-packages/django/db/backends/util.py", line 40, in execute
    return self.cursor.execute(sql, params)
  File "/home/stu/.virtualenvs/the_app/local/lib/python2.7/site-packages/django/db/backends/postgresql_psycopg2/base.py", line 52, in execute
    return self.cursor.execute(query, args)
django.db.utils.DatabaseError: current transaction is aborted, commands ignored until end of transaction block

In the end the solution was simple, just check for the args where we need the refresh to happen automatically:

## Automatically reload when forms or tests changed
try:
    from django.conf import settings

    if settings.DEBUG:
        import sys
        if sys.argv == ['manage.py', 'autotest'] or sys.argv == ['manage.py', 'runserver']:
                # Need to check params as otherwise this can break syncdb, reset and
                # Friends !!
                import forms, util, tests
except:
    pass

Hopefully this will be helpful to somebody with a similar error or that wants autotest or runserver to see more files.
 

This article was particularly helpful in debugging this:  debugging django syncdb

https://gitorious.org/pycairo-ctypes/pycairo-ctypes

This is a really rough proof of concept that the pycairo API can be implemented with ctypes + metclasses.

So far only ImageSurface is supported on the SVG backend, along with Contexts.   The nice thing about this is that you can use a pycairo like API on pypy, where things should be faster (in theory).

There’s a test that can be run to show the outputs the same for pycairo and cairo ctypes.

To install you’ll need to do

pip install pycha

Heres the code for a simple view to output a chart directly to SVG:

# views.py

from StringIO import StringIO
from django.http import HttpResponse

import cairo

def colors(request):
    in_req = 1

    svg_buffer = StringIO()

    width, height = (500, 400)
    surface = cairo.SVGSurface(svg_buffer, width, height)

    dataSet = (
     ('dataSet 1', ((0, 1), (1, 3), (2, 2.5))),
     ('dataSet 2', ((0, 2), (1, 4), (2, 3))),
     ('dataSet 3', ((0, 5), (1, 1), (2, 0.5))),
    )

    options = {
       'legend': {'hide': True},
       'background': {'color': '#f0f0f0'},
    }

    #import pycha.bar
    #chart = pycha.bar.VerticalBarChart(surface, options)

    import pycha.line
    chart = pycha.line.LineChart(surface, options)
    chart.addDataset(dataSet)
    chart.render()

    del chart
    del surface

    response = ''
    response = HttpResponse(mimetype='image/svg+xml')
    svg_buffer.seek(0)
    response.write( svg_buffer.read() )
    return response

The basic idea is that – instead of the chart outputting to an svg file, the output goes to a buffer, this is triggered by calling the destructors of the chart and it’s cairo surface.  Once the data is in the buffer, it is rewound and played back to the Http Response.

Inline SVG

As is, this won’t work as inline svg, because outputting the XML preamble in the middle of the page will cause problems.  Below is an example that let’s you decide if you need the preamble (full SVG output), or not (SVG fragment for inclusion in a page or another SVG):

# Create your views here.

from StringIO import StringIO
from django.http import HttpResponse
from django.shortcuts import render_to_response

import cairo

XML_PREAMBLE = '<?xml version="1.0" encoding="UTF-8"?>'

def colors_chart(inline = False):
    """
    Generate colours chart

    Set inline to True to disable the XML preamble
    """
    in_req = 1

    svg_buffer = StringIO()

    width, height = (500, 400)
    surface = cairo.SVGSurface(svg_buffer, width, height)

    dataSet = (
     ('dataSet 1', ((0, 1), (1, 3), (2, 2.5))),
     ('dataSet 2', ((0, 2), (1, 4), (2, 3))),
     ('dataSet 3', ((0, 5), (1, 1), (2, 0.5))),
    )

    options = {
       'legend': {'hide': True},
       'background': {'color': '#f0f0f0'},
    }

    import pycha.bar
    chart = pycha.bar.VerticalBarChart(surface, options)

    #import pycha.line
    #chart = pycha.line.LineChart(surface, options)
    chart.addDataset(dataSet)
    chart.render()

    del chart
    del surface

    response = ''

    if inline:
        svg_buffer.seek(len(XML_PREAMBLE))
    else:
        svg_buffer.seek(0)
    return svg_buffer.read()

def colors_svg(request):
    """ render a pure SVG chart """
    response = HttpResponse(mimetype='image/svg+xml')
    response.write(colors_chart(inline = False))
    return response

def index(request):
    """ render a chart into the template """
    chart_svg = colors_chart(inline = True)

    return render_to_response(
        'shapes_index.html',
        { "chart" : chart_svg },
        mimetype='application/xhtml+xml')

An example project with the above code is available here:
pycha_django

[EDIT 25/2/2011] Fixed PyCha URL

Oops, I’ve been using TCC/LE by JPSoft as my shell… the following doesn’t work in the normal command prompt

[/EDIT]

I just had a look at SET and it lets you set user/system variables:

Display, create, modify, or delete environment variables.

SET [/A /D /E /P /R file... /S /U /V /X] [name[=][value ]]
        file:  One or more files containing variable definitions
        /A(rithmetic)           /S(ystem variables)
        /D(efault variables)    /U(ser variables)
        /E(nv vars)             /V(olatile variables)
        /R(ead from file)       /X override VariableExclude
        /P(ause)

So to set save a variables MYAPP_HOME as the current directory, just do

SET /U MYAPP_HOME=%CD

Wish I’d have looked that up a few years ago, it’ll save a few seconds next time I need to setup some dev sdk

While it works OK, I feel like I’m missing a higher level audio library (especially having seen Minim, for C++ and Java).

To run it in shoebot:

sbot -w audiobot.bot

audiobot.bot

# Major library imports
import atexit
import pyaudio
from numpy import zeros, short, fromstring, array
from numpy.fft import fft

NUM_SAMPLES = 512
SAMPLING_RATE = 11025

def setup():
    size(350, 260)
    speed(SAMPLING_RATE / NUM_SAMPLES)

_stream = None

def read_fft():
    global _stream
    pa = None

    def cleanup_audio():
        if _stream:
            _stream.stop_stream()
            _stream.close()
        pa.terminate()

    if _stream is None:
        pa = pyaudio.PyAudio()
        _stream = pa.open(format=pyaudio.paInt16, channels=1,
                           rate=SAMPLING_RATE,
                           input=True, frames_per_buffer=NUM_SAMPLES)
        atexit.register(cleanup_audio)

    audio_data  = fromstring(_stream.read(NUM_SAMPLES), dtype=short)
    normalized_data = audio_data / 32768.0

    return fft(normalized_data)[1:1+NUM_SAMPLES/2]

def flatten_fft(scale = 1.0):
    """
    Produces a nicer graph, I'm not sure if this is correct
    """
    for i, v in enumerate(read_fft()):
        yield scale * (i * v) / NUM_SAMPLES

def triple(audio):
    '''return bass/mid/treble'''
    c = audio.copy()
    c.resize(3, 255 / 3)
    return c

def draw():
    '''Draw 3 different colour graphs'''
    global NUM_SAMPLES
    audio = array(list(flatten_fft(scale = 80)))
    freqs = len(audio)
    bass, mid, treble = triple(audio)

    colours = (0.5, 1.0, 0.5), (1, 1, 0), (1, 0.2, 0.5)

    fill(0, 0, 1)
    rect(0, 0, WIDTH, 400)
    translate(50, 200)

    for spectrum, col in zip((bass, mid, treble), colours):
        fill(col)
        for i, s in enumerate(spectrum):
            rect(i, 0, 1, -abs(s))
        else:
            translate(i, 0)

    audio = array(list(flatten_fft(scale = 80)))