Golly Python script to output meta-life animation

from __future__ import division

import golly as g
from math import floor, ceil, log
from os import system, unlink

resx, resy = 1920, 1080 # woo 1080p
osa = 3 # 3x3 oversampling
framerate = 30
#resx, resy = 160, 90
#osa = 2
#framerate = 5
framecount = framerate*90 # 90 seconds long seems reasonable
outputmask = "/home/phlip/lifeanim/%08d.%s" # outputmask % (frameno, extension)
cellsize = osa # make cells larger by a full pixel in each direction, to cut down on moire effects

centrex, centrey = 114500, 4365
initw, inith = 96, 54
finalscale = 11.0 # so that we scale out by a factor of 2**11 over the animation
finalratefact = 17.0  # so that we speed up by a factor of 2**17 over the animation (the metapixels animate at about 2**-15 of the speed)
initrate = 1 # initially approx one step per second
initrateadj = initrate * framecount/framerate/(finalratefact*log(2)) # magic calculation to make it so that d/dt of setframe(t) at 0 is initrate

curstep = 0
def setstep(n):
    global curstep
    n = int(round(n))
    if n < curstep:
        return
    g.run(n - curstep)
    curstep = n

def setframe(t):
    setstep(initrateadj * 2**(finalratefact * t))

class Rect:
    def __init__(self, l, t, w, h):
        self.left = l
        self.top = t
        self.width = w
        self.height = h

def calcscale(t):
    if t < 3*framerate/framecount:
        t = 3*framerate/framecount # don't zoom out for the first 3 seconds
    w = initw * 2**(finalscale * t)
    h = inith * 2**(finalscale * t)
    l = centrex - w / 2.0
    t = centrey - h / 2.0
    return Rect(l,t,w,h)

def clamp(x,minim,maxim):
    if x < minim:
        return minim
    if x > maxim:
        return maxim
    return x

def doframe(n):
    t = n/framecount
    setframe(t)
    sc = calcscale(t)
    # get all the cells in the view area
    cells = g.getcells([sc.left, sc.top, sc.width, sc.height])
    # generate a large image (for oversampling)
    output = [[0 for x in xrange(resx * osa)] for y in xrange(resy * osa)]
    # draw all the live cells on the image
    for i in xrange(0, len(cells), 2):
        cellx, celly = cells[i:i+2]
        # find the bounds of this cell on the screen
        xmin = int(floor(((cellx - sc.left) / sc.width) * resx * osa))
        xmax = int(floor(((cellx - sc.left + 1) / sc.width) * resx * osa)) + 1
        ymin = int(floor(((celly - sc.top) / sc.height) * resy * osa))
        ymax = int(floor(((celly - sc.top + 1) / sc.height) * resy * osa)) + 1
        # make the cells slightly larger and overlapping, to reduce the moire effects
        xmin -= cellsize
        ymin -= cellsize
        xmax += cellsize
        ymax += cellsize
        # draw the cell on the image
        xmin = clamp(xmin, 0, resx * osa)
        xmax = clamp(xmax, 0, resx * osa)
        ymin = clamp(ymin, 0, resy * osa)
        ymax = clamp(ymax, 0, resy * osa)
        for y in xrange(ymin, ymax):
            output[y][xmin:xmax] = [1] * (xmax - xmin)
    # Scale down the oversampled image to the target size, by averaging
    if osa > 1:
        output = [[sum(output[i][j] for i in xrange(y*osa,(y+1)*osa) for j in xrange(x*osa,(x+1)*osa)) for x in xrange(resx)] for y in xrange(resy)]
    # Save the image as a PGM, and then use ImageMagick to convert it to PNG
    with open(outputmask % (n, "pgm"), 'w') as fp:
        fp.write("P2\n%d %d\n%d\n" % (resx, resy, osa*osa))
        sc = calcscale(t)
        for row in output:
            fp.write(' '.join(map(str,row)))
            fp.write('\n')
    system("convert %s -depth 8 %s" % (outputmask % (n, "pgm"), outputmask % (n, "png")))
    unlink(outputmask % (n, "pgm"))

# Parameters so that I can run several instances of Golly and have them render separate slices of the frames
# and thus make use of my multicore CPU...
def main(step=1,start=0):
    global curstep
    g.reset()
    curstep = 0
    for i in xrange(start,framecount,step):
        g.show("Frame %d of %d..." % (i+1, framecount));
        doframe(i)

main()
# or, make copies of the script and have each copy have one of, eg:
#main(3,0)
#main(3,1)
#main(3,2)
# and then run three instances of Golly and have each run a different copy of the script