Python script to drive PoDoFo to impose 2x2 for hardcover

#!/usr/bin/python
# -*- coding: utf-8 -*-

import sys
import re
import os
from pyPdf import PdfFileWriter, PdfFileReader

# Verbosity 0 means absolute silence
# 1 means only error messages
# 2 adds warnings as well
# 3 adds information about what's going on
# 4 adds useless chitchat
# 5 debug
verbose = 3

# Unit to PS points conversion
mm = 2.834650

# pages per set: 8, 16, 24, 32 ...
div = 16

# pages per fold
fold = 8

# print full pane
print_full_pane = True


def usage():
    print "Give files you want imposed as arguments."

class Page:
    def __init__(self, height, width):
        self.height = height
        self.width = width


class Margins:
    def __init__(self, top = 0, bottom = 0, left = None, right = None,
        inside = None, outside = None):
        self.top = top
        self.bottom = bottom
        if inside or outside:
            if inside:
                self.inside = inside
            else:
                self.inside = 0
            self.left = self.inside
            if outside:
                self.outside = outside
            else:
                self.outside = 0
            self.right = self.outside
            self.inoutside = True
        else:
            if left:
                self.left = left
            else:
                self.left = 0
            if right:
                self.right = right
            else:
                self.right = 0
            self.inoutside = False


class PdfDoc:
    filename = False
    pages = 0

    def __init__(self, path):
        self.path = path
        self.dir, self.filename = os.path.split(path)
        self.pdf = PdfFileReader(file(self.path))
        self.info = self.pdf.getDocumentInfo()
        self.pages = self.pdf.getNumPages()
        self.mediabox = self.pdf.getPage(0).mediaBox
        self.page = Page(
            width = float(self.mediabox[2] - self.mediabox[0]),
            height = float(self.mediabox[3] - self.mediabox[1]))
        if verbose >= 3:
            print('')
            print('Document: %s (%.1f MB)' % (self.filename,
                os.path.getsize(self.path) / 1048576))
            if self.info.has_key('/Title') and \
                self.info['/Title'] != '':
                print('Title: %s' % self.info['/Title'])
            if self.info.has_key('/Author') and self.info['/Author'] != '':
                print('Author: %s' % self.info['/Author'])
            if self.info.has_key('/CreationDate'):
                date = self.info['/CreationDate'][2:]
            else:
                date = '00000000000000000000'
            print('Created on %s-%s-%s %s:%s with %s %s' %
                (date[0:4], date[4:6], date[6:8], date[8:10], date[10:12],
                self.info['/Producer'], self.info['/Creator']))
            print('Document dimensions: %.2f mm x %.2f mm' %
                (self.page.width / mm, self.page.height / mm))
            print('')


class Plan:
    plate_margins = Margins()
    pages = []

    def __init__(self, document):
        self.document = document
        self.page_margins = Margins()
        self.plate_margins = Margins()

    def addPage(self, ref, dest, rot=0, left=False,  bottom=False, x=False, y=False):
        if ref > self.document.pages:
            return
        if left and bottom and rot != 180:
            x = self.x[left-1]
            y = self.y[bottom-1]
        elif left and bottom and rot == 180:
            x = self.x180[left-1]
            y = self.y180[bottom-1]
        if rot == 180:
            x += self.sheet.width
            y += self.sheet.height
        self.pages.append("%d; %d; %d; %f; %f;\n" % (ref, dest, rot, x, y))
        #print ref, dest, rot, x, y

    def complete(self):
        f = open('/tmp/plan.plan', 'w')
        #print self.plate.width, self.plate.height
        f.write('$PageWidth=%f\n$PageHeight=%f;\n\n' % (self.plate.width,
            self.plate.height))
        f.write(''.join(self.pages))
        f.close()

        #os.system('podofoimpose "%s" "%s.out.pdf" /tmp/plan.plan' %
        #    (self.document.path, self.document.path))
        fin, fout = os.popen4('podofoimpose "%s" "%s.out.pdf" /tmp/plan.plan' %
            (self.document.path, self.document.path))
        result = fout.read()
        if verbose >= 4:
            print result

    def pageDimensions(self, sheet):
        self.sheet = sheet

    def dimensions(self):
        # Output page dimensions
        # 2x2 nup
        if print_full_pane:
            self.plate = Page(
                width = 2 * self.sheet.width +
                    self.plate_margins.left + self.plate_margins.right + \
                    2 * (self.page_margins.left + self.page_margins.right),
                height = 2 * self.sheet.height +
                    self.plate_margins.top + self.plate_margins.bottom + \
                    2 * (self.page_margins.top + self.page_margins.bottom))

            # Output positions
            if self.page_margins.inoutside:
                self.x = []
                self.x.append(self.plate_margins.left + self.page_margins.outside)
                self.x.append(self.plate_margins.left + 2 * self.page_margins.inside + \
                    self.page_margins.outside + self.sheet.width)
            else:
                self.x = []
                self.x.append(self.plate_margins.left + self.page_margins.left)
                self.x.append(self.plate_margins.left + 2 * self.page_margins.left + \
                    self.page_margins.right + self.sheet.width)
            self.y = []
            self.y.append(self.plate_margins.bottom + self.page_margins.bottom)
            self.y.append(self.plate_margins.bottom + 2 * self.page_margins.bottom + \
                self.page_margins.top + self.sheet.height)
            if self.page_margins.inoutside:
                # Output positions for 180 deg rotated pages
                self.x180 = []
                self.x180.append(self.plate_margins.left + self.page_margins.outside)
                self.x180.append(self.plate_margins.left + 2 * self.page_margins.inside + \
                    self.page_margins.outside + self.sheet.width)
            else:
                self.x180 = []
                self.x180.append(self.plate_margins.left + self.page_margins.left)
                self.x180.append(self.plate_margins.left + 2 * self.page_margins.left + \
                    self.page_margins.right + self.sheet.width)
            self.y180 = []
            self.y180.append(self.plate_margins.bottom + self.page_margins.bottom)
            self.y180.append(self.plate_margins.bottom + self.page_margins.bottom + self.sheet.height + 2*self.page_margins.top)
        else:
            # we print half pane
            if self.page_margins.inoutside:
                print 'jee'
                self.plate = Page(
                    width = 2 * self.sheet.width +
                        self.plate_margins.left + self.plate_margins.right + \
                        2 * (self.page_margins.inside + self.page_margins.outside),
                    height = 1 * self.sheet.height +
                        self.plate_margins.top + self.plate_margins.bottom + \
                        1 * (self.page_margins.top + self.page_margins.bottom))

                # Output positions
                self.x = []
                self.x.append(self.plate_margins.left + self.page_margins.outside)
                self.x.append(self.plate_margins.left + 2 * self.page_margins.inside + \
                    self.page_margins.outside + self.sheet.width)
                self.y = []
                self.y.append(self.plate_margins.bottom + self.page_margins.bottom)
                # Output positions for 180 deg rotated pages
                self.x180 = []
                self.x180.append(self.plate_margins.left + self.page_margins.outside)
                self.x180.append(self.plate_margins.left + 2 * self.page_margins.inside + \
                    self.page_margins.outside + self.sheet.width)
                self.y180 = []
                self.y180.append(self.plate_margins.bottom + self.page_margins.top)
            else:
                print 'buu'
                self.plate = Page(
                    width = 2 * self.sheet.width +
                        self.plate_margins.left + self.plate_margins.right + \
                        2 * (self.page_margins.left + self.page_margins.right),
                    height = 1 * self.sheet.height +
                        self.plate_margins.top + self.plate_margins.bottom + \
                        1 * (self.page_margins.top + self.page_margins.bottom))

                # Output positions
                self.x = []
                self.x.append(self.plate_margins.left + self.page_margins.left)
                self.x.append(self.plate_margins.left + 2 * self.page_margins.left + \
                    self.page_margins.right + self.sheet.width)
                self.y = []
                self.y.append(self.plate_margins.bottom + self.page_margins.bottom)


class prepress:
    documents = []

    def __init__(self):
        # First we parse arguments
        if len(sys.argv) != 2:
            usage()
            exit()
        filename = sys.argv[1]

        document = PdfDoc(filename)

        plan = Plan(document)
        plan.pageDimensions(document.page)
        plan.plate_margins = Margins(
            left   = 0*mm,
            right  = 0*mm,
            top    = 0*mm,
            bottom = 0*mm)
        # instead of left/right one could use inside or outside
        plan.page_margins = Margins(
            inside   = 0*mm,
            outside  = 3*mm,
            top    = 3*mm,
            bottom = 3*mm)
        plan.dimensions()

        # Deciding of pages division to panes
        remaining = document.pages % fold
        if remaining != 0:
            added_pages = fold - remaining
        else:
            added_pages = 0
        total_pages = document.pages + added_pages
        full_sequences = total_pages / div

        pages = []
        for p in xrange(1, total_pages+1):
            if p <= document.pages:
                pages.append(p)
            else:
                pages.append(False)

        dest = 1
        start = 0
        for i in xrange(0, full_sequences):
            subpages = self.foldable_brochure(pages[start:start+div])
            start += div
            if print_full_pane:
                self.four_per_page(plan, subpages, dest)
                dest += div/fold*2
            else:
                self.four_as_two_per_page(plan, subpages, dest)
                dest += div/fold*4

        if start < total_pages:
            subpages = self.foldable_brochure(pages[start:total_pages])
            if print_full_pane:
                self.four_per_page(plan, subpages, dest)
            else:
                self.four_as_two_per_page(plan, subpages, dest)
        plan.complete()

    def four_per_page(self, plan, page_list, page):
        for i in xrange(len(page_list)/4):
            plan.addPage(ref=page_list[i*4+0], dest=page+i, rot=180, left=1,  bottom=2)
            plan.addPage(ref=page_list[i*4+1], dest=page+i, rot=180, left=2,  bottom=2)
            plan.addPage(ref=page_list[i*4+2], dest=page+i, rot=0, left=1,  bottom=1)
            plan.addPage(ref=page_list[i*4+3], dest=page+i, rot=0, left=2,  bottom=1)

    def four_as_two_per_page(self, plan, page_list, page):
        for i in xrange(len(page_list)/4):
            plan.addPage(ref=page_list[i*4+0], dest=page+i*2, rot=180, left=1,  bottom=1)
            plan.addPage(ref=page_list[i*4+1], dest=page+i*2, rot=180, left=2,  bottom=1)
            plan.addPage(ref=page_list[i*4+2], dest=page+i*2+1, rot=0, left=1,  bottom=1)
            plan.addPage(ref=page_list[i*4+3], dest=page+i*2+1, rot=0, left=2,  bottom=1)

    def foldable_brochure(self, page_list):
        e = len(page_list)
        sequence = (e) / 8

        page_list_fold = []
        for i in xrange(sequence):
            page_list_fold.append(page_list[e-i*4-4])
            page_list_fold.append(page_list[i*4+3])
            page_list_fold.append(page_list[e-i*4-1])
            page_list_fold.append(page_list[i*4])
            page_list_fold.append(page_list[i*4+2])
            page_list_fold.append(page_list[e-i*4-3])
            page_list_fold.append(page_list[i*4+1])
            page_list_fold.append(page_list[e-i*4-2])
        return page_list_fold

if __name__=="__main__":
    d = prepress()