This program is an implementation of the ideas in
<>.  It
generated <>, a hundred-megapixel
PNG containing the full text of the King James Bible in a format that should be
readably printable on a 600dpi laser printer.

# -*- coding: utf-8 -*-
"""Render text to a given width using a proportional pixel font.

Without linebreaks except when it runs out of space on a line.

The font file is a black-and-white image whose height is one pixel
more than the height of the glyphs in the font.  The bottom row of
pixels indicates glyph boundaries: every black pixel in it is below
the rightmost column of a glyph.  (Therefore all glyphs are at least
one pixel wide.)  The other rows of pixels comprise the pixel of the
glyphs, using a black foreground and a white background.

The order of the glyphs is fairly bizarre.  There are 96 glyphs.  The
first 95 glyphs are for bytes 32-126; the 96th is the glyph for
newline, byte 10.

Here’s the font I’m using, as a base64-encoded PNG file.  The 96th
glyph looks like a sort of squished pilcrow.


This program will read the entire input into memory and construct an
output image for the whole thing at once, so it is limited in the size
of images that it can handle.  It seems to use about one byte of RAM
per output pixel.


from __future__ import division

import math
import sys

import Image

codepoints = range(32, 127) + [10]
glyph_indices = {}
for _glyph_index, _codepoint in enumerate(codepoints):
    glyph_indices[_codepoint] = _glyph_index

def main(argv):
    _, font_filename, n_columns, total_width, page_height = argv
    font =
    total_width = int(total_width)
    n_columns = int(n_columns)
    page_height = int(page_height)
    iwidth, iheight = font.size
    height = iheight - 1
    page_lines = int(math.floor(page_height, height))

    text =

    column_width = int(math.floor(total_width / n_columns))-1

    ends = glyph_ends(font)
    starts = [0] + [ii+1 for ii in ends[:-1]]
    widths = list(deltas(ends, -1))

    # How many lines would we need in all the columns together?
    n_lines = count_lines(widths, column_width, text)
    lines_per_column = int(math.ceil(n_lines / n_columns))
    pixel_height = lines_per_column * height

    glyphs = [get_glyph(font, starts, widths, glyph_index)
              for glyph_index in range(len(widths))]
    outbuf ='1', size=(total_width, pixel_height))
    for line, x, glyph_index in glyph_positions(widths, column_width, text):
        column, within_column = divmod(line, lines_per_column)
                     ((column_width+1) * column + x, within_column * height)), format='png')

def glyph_ends(font):
    "Read the bottom line of the font to get the widths."
    iwidth, iheight = font.size
    return [ii for ii in range(iwidth) if font.getpixel((ii, iheight-1))]

def deltas(seq, last=0):
    for item in seq:
        yield item - last
        last = item

def count_lines(widths, pixel_width, text):
    for full_lines, _, _ in glyph_positions(widths, pixel_width, text):
    return full_lines + 1

def glyph_positions(widths, pixel_width, text):
    """Yield (lineno, pixelcol, glyph_index) tuples for all the glyphs.

    lineno and pixelcol count from 0.
    full_lines, x = 0, 0

    for byte in text:
        glyph_index = glyph_indices[ord(byte)]
        width = widths[glyph_index]
        if width + x > pixel_width:
            full_lines += 1
            x = 0

        yield full_lines, x, glyph_index
        x += width
        assert x <= pixel_width
def get_glyph(font, starts, widths, glyph_index):
    iwidth, iheight = font.size
    height = iheight - 1
    x = starts[glyph_index]
    return font.crop((x, 0, x + widths[glyph_index], height))

if __name__ == '__main__':
To unsubscribe:

Reply via email to