pdf-impose 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d1c61ffc5f76f744484e97641eb3a42934e3517d
+  data.tar.gz: 30e272a0ec02dd406fa6fabad2e1ca7c3539c6fe
+SHA512:
+  metadata.gz: 98ec292d86c84b64742c5b76502cde1d67136118b108ddeb5a27d201cab34f0b9dbd9adecf216a5e5e5073fd418ad951c573ebf63e17c0830fb48e5c5450dbc1
+  data.tar.gz: 73f462fafcaab365289ed4f3d7439addaf44cc70322a20535607e33270a169a2c9b2cd9da6c91f5c3212617b6edb192607ea207d29f6d7103d1edd9bbb6c5600

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Jamis Buck
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,255 @@
+# PDF::Impose
+
+`PDF::Impose` is a utility and library for reformatting PDF files, in order to lay out multiple pages of the original document on a single page. The original pages are arranged in such a way that the new page may be folded and cut to produce a _signature_--a small booklet in which the pages are in the expected order. In this way, an existing PDF can be printed, folded, cut, and bound into a handmade book or booklet.
+
+This process of laying out pages in this way is called [_imposition_](https://en.wikipedia.org/wiki/Imposition).
+
+
+## Installation
+
+`PDF::Impose` and its dependencies may be installed via RubyGems:
+
+    $ gem install pdf-impose
+
+## Caveats
+
+This has been tested on a variety of PDFs, and while it works great for most, there are some that it does not work correctly on. Pull requests would be welcome, to increase the number of PDFs that can correctly be imposed.
+
+## Usage
+
+The easiest way to use `PDF::Impose` is via the command-line tool:
+
+    $ impose -h
+    Usage: impose [options] <input.pdf>
+      -l, --layout LAYOUT    The form to use when laying out pages for imposition.
+                             Default is "quarto".
+                             (Specify "list" to see all available forms.)
+      -o, --orient ORIENT    How each sheet should be oriented.
+                             Possible options are "portrait" or "landscape".
+                             Default is "portrait".
+      -f, --forms COUNT      The number of forms to use for each signature.
+                             Default is dependent on the form used.
+      -d, --dimensions DIM   Either the name of a paper size, or a WxH (width/height)
+                             specification. Measurements must be in points.
+                             Default is "LETTER".
+                             (Specify "list" to see all named paper sizes.)
+      -m, --margin SIZE      The minimum margin (in points) for the chosen form.
+                             Default is 36 points.
+      -s, --start PAGE       The page at which to start imposing.
+                             Default is 1.
+      -e, --end PAGE         The page at which to stop imposing.
+                             Default is the last page of the source document.
+      -M, --[no-]marks       Whether or not to include registration marks.
+                             Default is to include registration marks.
+      -O, --output FILENAME  The name of the file to which to write the resulting PDF.
+                             Default is the original filename with "imposed" appended.
+      -h, --help             This help screen.
+
+To impose an existing PDF in quarto on A4 sheets, the following would suffice:
+
+    $ impose -l quarto -d A4 my-document.pdf
+
+This would produce a new PDF called `my-document-imposed.pdf`.
+
+
+## Default Layouts and Forms
+
+The process of imposition takes a source document and lays out its pages in a particular form. The form used depends on how many pages you want to fit on a single sheet, and how many times you want to fold the paper to produce a signature.
+
+`PDF::Impose` supports several common imposition forms, which should satisfy most needs. If you need a specific layout, though, it is not hard to define a custom imposition form. (See the "minibook" example in this repository.)
+
+The following forms are supported by default.
+
+
+### Four-page card-fold (`card-fold4`)
+
+The four-page card fold takes a four-page document and lays out the pages on a single sheet in the following order:
+
+<img src="layouts/card-fold4.png" width="200" />
+
+When printed, the page can be folded in half twice to make a simple pamphlet of the original four pages. This form works best with the sheet in portrait orientation.
+
+    $ impose -o portrait -l card-fold4 document.pdf
+    # produces document-imposed.pdf
+
+
+### Eight-page card-fold (`card-fold8`)
+
+The eight-page card fold takes an eight-page document and lays out the pages on a single sheet in the following order:
+
+<img src="layouts/card-fold8.png" width="400" />
+
+When printed, the page can be folded in half three times to make a simple pamphlet of the original eight pages. This form works best with the sheet in landscape orientation.
+
+    $ impose -o landscape -l card-fold8 document.pdf
+    # produces document-imposed.pdf
+
+
+### Folio (`folio`)
+
+This form applies two pages to each side of a sheet of paper, in the following order:
+
+Recto (front):
+
+<img src="layouts/folio - recto.png" width="200" />
+
+Verso (back):
+
+<img src="layouts/folio - verso.png" width="200" />
+
+When printed, the page can be folded in half to produce a simple pamphlet of four pages. For documents of more than four pages, multiple sheets can be folded and nested inside each other to form a signature. By default, up to eight forms (four sheets, one form for each side of the sheet) will be treated as a single signature. For documents of more than eight pages, multiple signatures will be produced, though you can control how many forms to include in a signature with the `--forms` switch.
+
+This form works best with landscape orientation.
+
+    $ impose -o landscape -l folio document.pdf
+    # produces document-imposed.pdf
+
+
+### Quarto (`quarto`)
+
+This form applies four pages to each side of a sheet of paper, in the following order:
+
+Recto (front):
+
+<img src="layouts/quarto - recto.png" width="200" />
+
+Verso (back):
+
+<img src="layouts/quarto - verso.png" width="200" />
+
+When printed, the page can be folded in half twice to produce a simple pamphlet of eight pages. For documents of more than eight pages, multiple sheets can be folded and nested inside each other to form a signature. By default, up to four forms (two sheets, one form for each side of the sheet) will be treated as a single signature. For documents of more than sixteen pages, multiple signatures will be produced, though you can control how many forms to include in a signature with the `--forms` switch.
+
+This form works best with portrait orientation.
+
+    $ impose -o portrait -l quarto document.pdf
+    # produces document-imposed.pdf
+
+
+### Sexto (`sexto`)
+
+This form applies six pages to each side of a sheet of paper, in the following order:
+
+Recto (front):
+
+<img src="layouts/sexto - recto.png" width="200" />
+
+Verso (back):
+
+<img src="layouts/sexto - verso.png" width="200" />
+
+When printed, the page can be folded three times to produce a simple pamphlet of twelve pages. For documents of more than twelve pages, multiple sheets can be folded and nested inside each other to form a signature. By default, up to four forms (two sheets, one form for each side of the sheet) will be treated as a single signature. For documents of more than twenty-four pages, multiple signatures will be produced, though you can control how many forms to include in a signature with the `--forms` switch.
+
+This form is awkward to apply when dealing with standard letter-sized pages, but for non-standard page sizes it may work very well.
+
+    $ impose -l sexto document.pdf
+    # produces document-imposed.pdf
+
+
+### Octavo (`octavo`)
+
+This form applies eight pages to each side of a sheet of paper, in the following order:
+
+Recto (front):
+
+<img src="layouts/octavo - recto.png" width="400" />
+
+Verso (back):
+
+<img src="layouts/octavo - verso.png" width="400" />
+
+When printed, the page can be folded three times to produce a simple pamphlet of sixteen pages. For documents of more than sixteen pages, multiple sheets can be folded and nested inside each other to form a signature. By default, two forms (one sheet, one form for each side of the sheet) will be treated as a single signature. For documents of more than sixteen pages, multiple signatures will be produced, though you can control how many forms to include in a signature with the `--forms` switch.
+
+This form works well in landscape orientation.
+
+    $ impose -o landscape -l octavo document.pdf
+    # produces document-imposed.pdf
+
+
+### Duodecimo (`duodecimo`)
+
+This form applies twelve pages to each side of a sheet of paper, in the following order:
+
+Recto (front):
+
+<img src="layouts/duodecimo - recto.png" width="200" />
+
+Verso (back):
+
+<img src="layouts/duodecimo - verso.png" width="200" />
+
+When printed, the bottommost strip can be separated and folded in quarto, while the remaining octavo is folded per octavo. The octavo is then nested inside the quarto to form the signature. For documents of more than twenty-four pages, multiple signatures will be produced, though you can control how many forms to include in a signature with the `--forms` switch.
+
+This form is awkward to apply when dealing with standard letter-sized pages, but for non-standard page sizes it may work very well.
+
+    $ impose -l duodecimo document.pdf
+    # produces document-imposed.pdf
+
+
+### Duodecimo (Quarto-inside) (`duodecimo-i`)
+
+This form applies twelve pages to each side of a sheet of paper, in the following order:
+
+Recto (front):
+
+<img src="layouts/duodecimo-i - recto.png" width="200" />
+
+Verso (back):
+
+<img src="layouts/duodecimo-i - verso.png" width="200" />
+
+When printed, the bottommost strip can be separated and folded in quarto, while the remaining octavo is folded per octavo. The quarto is then nested inside the octavo to form the signature. (Note that this is slightly different than how the `duodecimo` form works!) For documents of more than twenty-four pages, multiple signatures will be produced, though you can control how many forms to include in a signature with the `--forms` switch.
+
+This form is awkward to apply when dealing with standard letter-sized pages, but for non-standard page sizes it may work very well.
+
+    $ impose -l duodecimo-i document.pdf
+    # produces document-imposed.pdf
+
+
+### Duodecimo (Two-Cut) (`duodecimo-2c`)
+
+This form applies twelve pages to each side of a sheet of paper, in the following order:
+
+Recto (front):
+
+<img src="layouts/duodecimo-2c - recto.png" width="200" />
+
+Verso (back):
+
+<img src="layouts/duodecimo-2c - verso.png" width="200" />
+
+When printed, each strip of four can be separated and folded in quarto, with the quartos nested to form the signature. (Note that this is different than how the `duodecimo` form works!) For documents of more than twenty-four pages, multiple signatures will be produced, though you can control how many forms to include in a signature with the `--forms` switch.
+
+This form is awkward to apply when dealing with standard letter-sized pages, but for non-standard page sizes it may work very well.
+
+    $ impose -l duodecimo-2c document.pdf
+    # produces document-imposed.pdf
+
+
+### Sextodecimo (`sextodecimo`)
+
+This form applies sixteen pages to each side of a sheet of paper, in the following order:
+
+Recto (front):
+
+<img src="layouts/sextodecimo - recto.png" width="200" />
+
+Verso (back):
+
+<img src="layouts/sextodecimo - verso.png" width="200" />
+
+When printed, the sheet is cut in half to form two octavos which, when folded, are nested to form the signature.  For documents of more than thirty-two pages, multiple signatures will be produced, though you can control how many forms to include in a signature with the `--forms` switch.
+
+This form works best in portrait mode when used with standard paper sizes.
+
+    $ impose -o portrait -l sextodecimo document.pdf
+    # produces document-imposed.pdf
+
+
+## Author
+
+Jamis Buck <jamis@jamisbuck.org>
+
+
+## License
+
+This code is released and distributed under the terms of the MIT license. See the associated `MIT-LICENSE` file for details.

data/bin/impose

@@ -0,0 +1,138 @@
+#!/bin/sh ruby
+
+require 'optparse'
+require 'pdf/impose/builder'
+
+def parse_page_size(dim)
+  match = dim.match(/^(\d+)x(\d+)$/)
+  if match
+    [match[1].to_i, match[2].to_i]
+  else
+    dim
+  end
+end
+
+def show_available_forms!
+  puts 'Available forms (with aliases, if any):'
+  PDF::Impose::Builder::PRIMARY_LAYOUTS.keys.each do |key|
+    aliases = if PDF::Impose::Builder::ALIASES[key].any?
+                ' (' + PDF::Impose::Builder::ALIASES[key].join(', ') + ')'
+              else
+                ''
+              end
+
+    puts " * #{key}#{aliases}"
+  end
+
+  exit(-1)
+end
+
+def show_available_paper_sizes!
+  puts 'Named paper sizes (with dimensions in points):'
+  PDF::Core::PageGeometry::SIZES.each do |name, (width, height)|
+    puts " * #{name} - #{width}x#{height}"
+  end
+
+  exit(-1)
+end
+
+options = {
+  layout: 'quarto',
+  orientation: :portrait,
+  forms_per_signature: nil,
+  page_size: 'LETTER',
+  margin: 36,
+  start_page: 1,
+  end_page: nil,
+  marks: true
+}
+
+output_filename = nil
+
+OptionParser.new do |parser|
+  parser.banner = "Usage: #{File.basename($PROGRAM_NAME)} [options] <input.pdf>"
+  parser.summary_indent = "  "
+  parser.summary_width = 22
+
+  parser.on('-l', '--layout LAYOUT',
+            'The form to use when laying out pages for imposition.',
+            "Default is \"#{options[:layout]}\".",
+            '(Specify "list" to see all available forms.)'
+  ) do |layout|
+    show_available_forms! if layout == 'list'
+    options[:layout] = layout
+  end
+
+  parser.on('-o', '--orient ORIENT',
+            'How each sheet should be oriented.',
+            'Possible options are "portrait" or "landscape".',
+            "Default is \"#{options[:orientation]}\"."
+  ) do |orientation|
+    options[:orientation] = orientation.to_sym
+  end
+
+  parser.on('-f', '--forms COUNT', Integer,
+            'The number of forms to use for each signature.',
+            'Default is dependent on the form used.'
+  ) do |count|
+    options[:forms_per_signature] = count
+  end
+
+  parser.on('-d', '--dimensions DIM',
+            'Either the name of a paper size, or a WxH (width/height)',
+            'specification. Measurements must be in points.',
+            "Default is \"#{options[:page_size]}\".",
+            '(Specify "list" to see all named paper sizes.)'
+  ) do |dim|
+    show_available_paper_sizes! if dim == 'list'
+    options[:page_size] = parse_page_size(dim)
+  end
+
+  parser.on('-m', '--margin SIZE', Integer,
+            'The minimum margin (in points) for the chosen form.',
+            "Default is #{options[:margin]} points."
+  ) do |size|
+    options[:margin] = size
+  end
+
+  parser.on('-s', '--start PAGE', Integer,
+            'The page at which to start imposing.',
+            "Default is #{options[:start_page]}."
+  ) do |page|
+    options[:start_page] = page
+  end
+
+  parser.on('-e', '--end PAGE', Integer,
+            'The page at which to stop imposing.',
+            "Default is the last page of the source document."
+  ) do |page|
+    options[:end_page] = page
+  end
+
+  parser.on('-M', '--[no-]marks',
+            'Whether or not to include registration marks.',
+            'Default is to include registration marks.'
+  ) do |marks|
+    options[:marks] = marks
+  end
+
+  parser.on('-O', '--output FILENAME',
+            'The name of the file to which to write the resulting PDF.',
+            'Default is the original filename with "imposed" appended.'
+  ) do |filename|
+    output_filename = filename
+  end
+
+  parser.on('-h', '--help',
+            'This help screen.'
+  ) do
+    puts parser.help
+    exit(-1)
+  end
+end.parse!
+
+filename = ARGV.first or abort 'please specify a PDF file to impose'
+imposer = PDF::Impose::Builder.new(filename, options)
+
+output_filename ||= File.basename(filename, '.pdf') + '-imposed.pdf'
+imposer.emit output_filename

data/lib/pdf/impose/builder.rb

@@ -0,0 +1,221 @@
+require 'pdf/reader'
+require 'prawn'
+require 'prawn/templates'
+
+require 'pdf/impose/ext'
+require 'pdf/impose/forms/card_fold'
+require 'pdf/impose/forms/duodecimo'
+require 'pdf/impose/forms/folio'
+require 'pdf/impose/forms/quarto'
+require 'pdf/impose/forms/octavo'
+require 'pdf/impose/forms/sexto'
+require 'pdf/impose/forms/sextodecimo'
+require 'pdf/impose/signature'
+
+module PDF
+  module Impose
+    class Builder
+      PRIMARY_LAYOUTS = {
+        'card-fold4' => PDF::Impose::Forms::CardFold::Quarto,
+        'card-fold8' => PDF::Impose::Forms::CardFold::Octavo,
+        'folio' => PDF::Impose::Forms::Folio,
+        'quarto' => PDF::Impose::Forms::Quarto,
+        'sexto' => PDF::Impose::Forms::Sexto,
+        'octavo' => PDF::Impose::Forms::Octavo,
+        'duodecimo' => PDF::Impose::Forms::Duodecimo::OneCutOutside,
+        'duodecimo-i' => PDF::Impose::Forms::Duodecimo::OneCutInside,
+        'duodecimo-2c' => PDF::Impose::Forms::Duodecimo::TwoCut,
+        'sextodecimo' => PDF::Impose::Forms::Sextodecimo::Nested
+      }.freeze
+
+      ALIASES = {
+        'card-fold4' => %w( card-fold ),
+        'card-fold8' => %w( ),
+        'folio' => %w( f fo ),
+        'quarto' => %w( 4to ),
+        'sexto' => %w( 6to 6mo ),
+        'octavo' => %w( 8vo octavo ),
+        'duodecimo' => %w( twelvemo 12mo ),
+        'duodecimo-i' => %w( twelvemo-i 12mo-i ),
+        'duodecimo-2c' => %w( twelvemo-2c 12mo-2c ),
+        'sextodecimo' => %w( sixteenmo 16mo )
+      }.freeze
+
+      LAYOUTS = ALIASES.keys.each_with_object({}) do |key, hash|
+        hash[key] = PRIMARY_LAYOUTS[key]
+        ALIASES[key].each { |name| hash[name] = hash[key] }
+      end.freeze
+
+      # source: the name of a PDF document to lay out
+      # options:
+      #   layout: quarto, octavo, etc.
+      #   page_size: passed through to Prawn
+      #   orientation: passed through to Prawn as :page_layout
+      #   forms_per_signature: defaults to layout.per_signature
+      #   margin: point size of margin of page (default = 32 points)
+      #   start_page: defaults to 1
+      #   end_page: defaults to last page of source document
+      #   marks: true or false, whether to include registration marks (default true)
+      def initialize(source, options={})
+        layout_arg = options[:layout]
+
+        @layout = if layout_arg.respond_to?(:recto)
+                    layout_arg
+                  else
+                    LAYOUTS[options[:layout].to_s.downcase]
+                  end
+
+        raise "`#{options[:layout]}' is not a supported layout" if @layout.nil?
+
+        @margin = options[:margin] || 36 # half inch
+        @marks = options.fetch(:marks, true)
+
+        @source = PDF::Reader.new(source)
+        @destination = Prawn::Document.new(
+          skip_page_creation: true, margin: 0,
+          page_size: options[:page_size], page_layout: options[:orientation])
+
+        @start_page = options[:start_page] || 1
+        @end_page = [options[:end_page] || 1e6, @source.page_count].min
+
+        @page_count = @end_page - @start_page + 1
+
+        @forms_per_signature = options[:forms_per_signature] ||
+                               @layout.per_signature
+        @pages_per_signature = @forms_per_signature * @layout.pages_per_form
+
+        @signature_count = (@page_count + @pages_per_signature - 1) /
+                           @pages_per_signature
+
+        @signatures = (1..@signature_count).map do |s|
+          first = (s - 1) * @pages_per_signature + @start_page
+          last = first + @pages_per_signature - 1
+          Signature.new(first, last)
+        end
+
+        _apply
+      end
+
+      def emit(filename)
+        @destination.render_file filename
+      end
+
+      def _apply
+        source_width = @source.page(1).page_object[:MediaBox][2]
+        source_height = @source.page(1).page_object[:MediaBox][3]
+
+        height = @destination.margin_box.height
+
+        sheet_width = @destination.margin_box.width - @margin * 2
+        sheet_height = height - @margin * 2
+
+        max_cell_width = sheet_width / @layout.columns_per_form
+        max_cell_height = sheet_height / @layout.rows_per_form
+
+        width_ratio = max_cell_width.to_f / source_width
+        height_ratio = max_cell_height.to_f / source_height
+        scale = [width_ratio, height_ratio].min
+
+        cell_width = source_width * scale
+        cell_height = source_height * scale
+
+        form_width = cell_width * @layout.columns_per_form
+        form_height = cell_height * @layout.rows_per_form
+
+        recto = true
+        @layout.layout_signatures(@signatures) do |form|
+          left = if recto
+                   @destination.margin_box.width - @margin - form_width
+                 else
+                   @margin
+                 end
+
+          @destination.start_new_page
+
+          _draw_guides(recto, form_width, form_height) if @marks
+
+          form.each_page do |page|
+            x = page.column * cell_width + left
+            y = height - (page.row + 1) * cell_height - @margin
+            @destination.page.import_page @source, page.number - 1,
+                                          x, y, cell_width, cell_height,
+                                          page.mirror?
+          end
+
+          recto = !recto
+        end
+
+        self
+      end
+
+      def _draw_guides(recto, width, height)
+        if recto
+          x2 = @destination.margin_box.width - @margin
+          x1 = x2 - width
+        else
+          x1 = @margin
+          x2 = x1 + width
+        end
+
+        y2 = @destination.margin_box.height - @margin
+        y1 = y2 - height
+
+        l1 = x1 - @margin / 2.0
+        l2 = l1 + @margin / 4.0
+        r1 = x2 + @margin / 4.0
+        r2 = x2 + @margin / 2.0
+
+        b1 = y1 - @margin / 2.0
+        b2 = y1 - @margin / 4.0
+        t1 = y2 + @margin / 4.0
+        t2 = y2 + @margin / 2.0
+
+        cx = recto ? (r1 + r2) / 2 : (l1 + l2) / 2
+        cy = (t1 + t2) / 2
+        radius = (r2 - r1) / 2
+
+        @destination.stroke do
+          @destination.line([l1, y1], [l2, y1])
+          @destination.line([l1, y2], [l2, y2])
+          @destination.line([r1, y1], [r2, y1])
+          @destination.line([r1, y2], [r2, y2])
+
+          @destination.line([x1, t1], [x1, t2])
+          @destination.line([x2, t1], [x2, t2])
+          @destination.line([x1, b1], [x1, b2])
+          @destination.line([x2, b1], [x2, b2])
+
+          @destination.circle([cx, cy], radius)
+          @destination.line([cx - 1.5 * radius, cy], [cx + 1.5 * radius, cy])
+          @destination.line([cx, cy - 1.5 * radius], [cx, cy + 1.5 * radius])
+        end
+
+        cut_rows = @layout.cut_row || []
+        if cut_rows.any?
+          row_height = height.to_f / @layout.rows_per_form
+
+          @destination.stroke do
+            cut_rows.each do |row|
+              y = y2 - row_height * row
+              @destination.line([l1, y], [l2, y])
+              @destination.line([r1, y], [r2, y])
+            end
+          end
+        end
+
+        cut_cols = @layout.cut_col || []
+        if cut_cols.any?
+          col_width = width.to_f / @layout.columns_per_form
+
+          @destination.stroke do
+            cut_cols.each do |col|
+              x = x1 + col_width * col
+              @destination.line([x, t1], [x, t2])
+              @destination.line([x, b1], [x, b2])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdf/impose/ext.rb

@@ -0,0 +1,92 @@
+module PDF
+  module Impose
+    module Ext
+      module Reference
+        def extract_content_stream
+          content = stream
+          content = content.filtered_stream if content.respond_to?(:filtered_stream)
+
+          if data[:Filter]
+            options = []
+
+            if data[:DecodeParams].is_a?(Hash)
+              options = [data[:DecodeParams]]
+            elsif data[:DecodeParams]
+              options = data[:DecodeParams]
+            end
+
+            Array(data[:Filter]).each_with_index do |filter, index|
+              content = PDF::Reader::Filter.
+                        with(filter, options[index]).filter(content)
+            end
+          end
+
+          content
+        end
+      end
+
+      module Page
+        def merge_object_resources(object)
+          object_resources = document.deref(object.data[:Resources])
+
+          object_resources.keys.each do |resource|
+            case object_resources[resource]
+            when ::Hash then
+              resources[resource] ||= {}
+              resources[resource].update(object_resources[resource])
+            when ::Array then
+              resources[resource] ||= []
+              resources[resource] |= object_resources[resource]
+            when PDF::Core::Reference then
+              resources[resource] = object_resources[resource]
+            else
+              klass = object_resources[resource].class
+              abort "unknown resource type #{klass} for #{resource}"
+            end
+          end
+        end
+
+        def import_page(reader, page_number, dx, dy, width, height, mirror)
+          ref = reader.objects.page_references[page_number]
+          return unless ref
+
+          object = document.state.store.
+                   send(:load_object_graph, reader.objects, ref)
+
+          merge_object_resources object
+
+          contents = object.data[:Contents]
+          contents = [contents] unless contents.is_a?(Array)
+
+          contents.each do |content|
+            content = content.extract_content_stream
+            box = object.data[:MediaBox]
+
+            scale = 1.0
+            width_ratio = width.to_f / box[2]
+            height_ratio = height.to_f / box[3]
+
+            scale = [width_ratio, height_ratio].min
+
+            document.save_graphics_state do
+              document.translate dx, dy
+              document.scale scale
+
+              if mirror
+                document.translate box[2], box[3]
+                document.rotate 180
+              end
+
+              document.add_content content
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'pdf/core'
+
+PDF::Core::Reference.include PDF::Impose::Ext::Reference
+PDF::Core::Page.include PDF::Impose::Ext::Page

data/lib/pdf/impose/form.rb

@@ -0,0 +1,149 @@
+require 'pdf/impose/page'
+
+module PDF
+  module Impose
+    # A Form represents a collection of pages that will be printed together on a
+    # single sheet of paper, in a particular (grid) layout.
+    #
+    # Form subclasses define the layout of individual pages via the `recto` and
+    # `verso` methods (`recto` == front, `verso` == back).
+    #
+    #    class Quarto < Form
+    #      per_signature 4
+    #
+    #      recto %w(3* *3),
+    #            %w(0. .0)
+    #
+    #      verso %w(1* *1),
+    #            %w(2. .2)
+    #    end
+    #
+    # Each row of the recto/verso configuration is a series of cells, representing
+    # individual pages. They take the following format:
+    #
+    #   *n OR .n OR n* OR n.
+    #
+    # 'n' is which pair from the signature is to be set in this position. If the
+    # dot or asterisk comes before the number, then the first element of the pair
+    # is used (the lower page number). If the dot or asterisk comes after, then
+    # the last element of the pair is used (the higher page number).
+    #
+    # A '.' means the page is set without rotation. A '*' means the page is
+    # rotated 180 degrees to turn it upside down.
+
+    class Form
+      class <<self
+        attr_reader :rows_per_form, :columns_per_form
+
+        def per_signature(n = nil)
+          @per_signature = n || @per_signature
+        end
+
+        def pages_per_form
+          rows_per_form * columns_per_form
+        end
+
+        def cut_row(*rows)
+          @cut_row = rows.any? ? rows : @cut_row
+        end
+
+        def cut_col(*cols)
+          @cut_col = cols.any? ? cols : @cut_col
+        end
+
+        # method can be :pages or :signatures (the default), and determines what
+        # the numbers in the recto/verso layouts represent.
+        def layout(method = nil)
+          @layout = method || @layout
+        end
+
+        def recto(*rows)
+          if rows.any?
+            @recto = _parse_configuration(rows)
+          else
+            @recto
+          end
+        end
+
+        def verso(*rows)
+          if rows.any?
+            @verso = _parse_configuration(rows)
+          else
+            @verso
+          end
+        end
+
+        def layout_signatures(signatures)
+          l = layout || :signatures
+          signatures.each do |signature|
+            offset = 0
+            while offset < signature.pairs.length
+              [recto, verso].compact.each do |side|
+                pages = []
+
+                side.each do |element|
+                  n = if l == :signatures
+                        idx = offset + element.offset
+                        signature.pairs[idx].send(element.which)
+                      else
+                        signature.pairs[offset].first + element.offset - 1
+                      end
+
+                  pages << PDF::Impose::Page.new(element.column, element.row,
+                                                 n, element.flip)
+                end
+
+                yield self.new(pages)
+              end
+
+              offset += pages_per_form
+            end
+          end
+
+          self
+        end
+
+        class LayoutElement < Struct.new(:column, :row, :offset, :which, :flip)
+        end
+
+        def _parse_configuration(rows)
+          @rows_per_form = rows.length
+          @columns_per_form = rows[0].length
+
+          [].tap do |config|
+            rows.each.with_index do |columns, row|
+              columns.each.with_index do |cell, column|
+                if cell !~ /^\s*([*.])?(\d+)([*.])?\s*$/
+                  raise "invalid form specification: #{cell.inspect}"
+                end
+
+                first = $1
+                ofs   = $2.to_i
+                last  = $3
+
+                if first.nil? && last.nil?
+                  raise "invalid form specification: #{cell.inspect}"
+                end
+
+                flip = (first || last) == '*'
+                config << LayoutElement.new(column, row, ofs,
+                                            first ? :first : :last, flip)
+              end
+            end
+          end
+        end
+      end
+
+      attr_reader :pages
+
+      def initialize(pages)
+        @pages = pages
+      end
+
+      def each_page
+        @pages.each { |page| yield page }
+        self
+      end
+    end
+  end
+end

data/lib/pdf/impose/forms/card_fold.rb

@@ -0,0 +1,25 @@
+require 'pdf/impose/form'
+
+module PDF
+  module Impose
+    module Forms
+      module CardFold
+        class Octavo < Form
+          per_signature 1
+
+          layout :page_numbers
+
+          recto %w(*3 *2 *1 *8),
+                %w(.4 .5 .6 .7)
+        end
+
+        class Quarto < Form
+          per_signature 1
+
+          recto %w(*0 0*),
+                %w(.1 1.)
+        end
+      end
+    end
+  end
+end

data/lib/pdf/impose/forms/duodecimo.rb

@@ -0,0 +1,67 @@
+require 'pdf/impose/form'
+
+module PDF
+  module Impose
+    module Forms
+      module Duodecimo
+        # cut into three 4to strips
+        class TwoCut < Form
+          per_signature 2
+
+          cut_row 1, 2
+
+          recto %w(.3 3. 0. .0),
+                %w(.7 7. 4. .4),
+                %w(.11 11. 8. .8)
+
+          verso %w(.1 1. 2. .2),
+                %w(.5 5. 6. .6),
+                %w(.9 9. 10. .10)
+        end
+
+        # one-cut, 4to on outside
+        class OneCutOutside < Form
+          per_signature 2
+
+          cut_row 2
+
+          recto %w(*4 4* 11* *11),
+                %w(.7 7. 8. .8),
+                %w(.3 3. 0. .0)
+
+          verso %w(*10 10* 5* *5),
+                %w(.9 9. 6. .6),
+                %w(.1 1. 2. .2)
+        end
+
+        # one-cut, 4to on inside
+        class OneCutInside < Form
+          per_signature 2
+
+          cut_row 2
+
+          recto %w(*0 0* 7* *7),
+                %w(.3 3. 4. .4),
+                %w(.11 11. 8. .8)
+
+          verso %w(*6 6* 1* *1),
+                %w(.5 5. 2. .2),
+                %w(.9 9. 10. .10)
+        end
+      end
+    end
+  end
+end
+
+# 0 | 1 . 24
+# 1 | 2 . 23
+# 2 | 3 . 22
+# 3 | 4 . 21
+# 4 | 5 . 20
+# 5 | 6 . 19
+# 6 | 7 . 18
+# 7 | 8 . 17
+# 8 | 9 . 16
+# 9 | 10 . 15
+# 10 | 11 . 14
+# 11 | 12 . 13

data/lib/pdf/impose/forms/folio.rb

@@ -0,0 +1,14 @@
+require 'pdf/impose/form'
+
+module PDF
+  module Impose
+    module Forms
+      class Folio < Form
+        per_signature 8
+
+        recto %w(0. .0)
+        verso %w(.1 1.)
+      end
+    end
+  end
+end

data/lib/pdf/impose/forms/octavo.rb

@@ -0,0 +1,26 @@
+require 'pdf/impose/form'
+
+module PDF
+  module Impose
+    module Forms
+      class Octavo < Form
+        per_signature 2
+
+        recto %w(3* *3 *0 0*),
+              %w(4. .4 .7 7.)
+
+        verso %w(1* *1 *2 2*),
+              %w(6. .6 .5 5.)
+      end
+    end
+  end
+end
+
+# 0 | 1 . 16
+# 1 | 2 . 15
+# 2 | 3 . 14
+# 3 | 4 . 13
+# 4 | 5 . 12
+# 5 | 6 . 11
+# 6 | 7 . 10
+# 7 | 8 . 9

data/lib/pdf/impose/forms/quarto.rb

@@ -0,0 +1,22 @@
+require 'pdf/impose/form'
+
+module PDF
+  module Impose
+    module Forms
+      class Quarto < Form
+        per_signature 4
+
+        recto %w(3* *3),
+              %w(0. .0)
+
+        verso %w(*2 2*),
+              %w(.1 1.)
+      end
+    end
+  end
+end
+
+# 0 | 1 . 8
+# 1 | 2 . 7
+# 2 | 3 . 6
+# 3 | 4 . 5

data/lib/pdf/impose/forms/sexto.rb

@@ -0,0 +1,26 @@
+require 'pdf/impose/form'
+
+module PDF
+  module Impose
+    module Forms
+      class Sexto < Form
+        per_signature 4
+
+        recto %w(0. .0),
+              %w(3* *3),
+              %w(4. .4)
+
+        verso %w(.1 1.),
+              %w(*2 2*),
+              %w(.5 5.)
+      end
+    end
+  end
+end
+
+# 0 | 1 . 12
+# 1 | 2 . 11
+# 2 | 3 . 10
+# 3 | 4 . 9
+# 4 | 5 . 8
+# 5 | 6 . 7

data/lib/pdf/impose/forms/sextodecimo.rb

@@ -0,0 +1,43 @@
+require 'pdf/impose/form'
+
+module PDF
+  module Impose
+    module Forms
+      module Sextodecimo
+        # two 8vo forms that nest one inside the other
+        class Nested < Form
+          per_signature 2
+
+          cut_row 2
+
+          recto %w(7* *7 *0 0*),
+                %w(4. .4 .3 3.),
+                %w(15* *15 *8 8*),
+                %w(12. .12 .11 11.)
+
+          verso %w(1* *1 *6 6*),
+                %w(2. .2 .5 5.),
+                %w(9* *9 *14 14*),
+                %w(10. .10 .13 13.)
+        end
+      end
+    end
+  end
+end
+
+# 0 | 1 . 32
+# 1 | 2 . 31
+# 2 | 3 . 30
+# 3 | 4 . 29
+# 4 | 5 . 28
+# 5 | 6 . 27
+# 6 | 7 . 26
+# 7 | 8 . 25
+# 8 | 9 . 24
+# 9 | 10 . 23
+# 10 | 11 . 22
+# 11 | 12 . 21
+# 12 | 13 . 20
+# 13 | 14 . 19
+# 14 | 15 . 18
+# 15 | 16 . 17

data/lib/pdf/impose/page.rb

@@ -0,0 +1,22 @@
+module PDF
+  module Impose
+    # A Page represents a single page from the source document. It
+    # indicates the page (by number), as well as where on the form (column/row)
+    # it should go, and whether it should be mirrored (inverted, by rotation)
+    # on the form.
+    class Page
+      attr_reader :column, :row
+      attr_reader :number
+      attr_reader :mirror
+
+      alias mirror? mirror
+
+      def initialize(column, row, number, mirror = false)
+        @column = column
+        @row = row
+        @number = number
+        @mirror = mirror
+      end
+    end
+  end
+end

data/lib/pdf/impose/signature.rb

@@ -0,0 +1,21 @@
+module PDF
+  module Impose
+    # A signature is composed of one or more forms.
+    class Signature
+      attr_reader :first, :last, :pairs
+
+      def initialize(first, last)
+        @first = first
+        @last = last
+
+        @pairs = []
+        f, l = first, last
+        while f < l
+          @pairs << [f, l]
+          f += 1
+          l -= 1
+        end
+      end
+    end
+  end
+end

data/lib/pdf/impose/version.rb

@@ -0,0 +1,5 @@
+module PDF
+  module Impose
+    VERSION = "1.0.0"
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: pdf-impose
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jamis Buck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prawn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: prawn-templates
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: pdf-reader
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: |2
+      Arrange pages of existing PDF documents so they fit on a single page, and
+      so they can be folded and cut to produce signatures that may then be assembled
+      to form a bound book.
+email:
+- jamis@jamisbuck.org
+executables:
+- impose
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- bin/impose
+- lib/pdf/impose/builder.rb
+- lib/pdf/impose/ext.rb
+- lib/pdf/impose/form.rb
+- lib/pdf/impose/forms/card_fold.rb
+- lib/pdf/impose/forms/duodecimo.rb
+- lib/pdf/impose/forms/folio.rb
+- lib/pdf/impose/forms/octavo.rb
+- lib/pdf/impose/forms/quarto.rb
+- lib/pdf/impose/forms/sexto.rb
+- lib/pdf/impose/forms/sextodecimo.rb
+- lib/pdf/impose/page.rb
+- lib/pdf/impose/signature.rb
+- lib/pdf/impose/version.rb
+homepage: http://github.com/jamis/impose
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A utility and library for imposition -- arranging pages on a sheet of paper
+  for optimal printing
+test_files: []