minicomic 0.0.1 → 0.2

data/README

@@ -3,8 +3,29 @@
 +minicomic+ is a library providing a set of rake rules for building
 print and web-ready files for minicomics from a set of SVG files.
 
-Currently, it is hard-coded for generating 5.5x8.5in format black-and-white
-comics of the sort most suitable for inexpensive photocopying.
+Originally designed for generating black-and-white folio minicomics of the sort
+most suited for inexpensive photocopying, the most recent versions produce
+color output by default.  If you are generating classic black-and-white
+minicomics, the options:
+
+ :color => :monochrome, :rasterize => false
+
+are recommended for getting optimum quality and file sizes.
+
+== getting minicomic
+
++minicomic+ is available from Rubyforge:
+
+http://www.rubyforge.org/projects/minicomic
+
+Or via RubyGems:
+
+ sudo gem install minicomic
+
+Development versions are available via git from repo.or.cz:
+
+ git://repo.or.cz/minicomic.git
+ http://repo.or.cz/r/minicomic.git
 
 == requirements
 
@@ -19,7 +40,7 @@ shell's path:
 * pngcrush
 
 If you're on Ubuntu, these correspond to the +inkscape+, +psutils+,
-+gs-gpl+, +imagemagick+ and +pngcrush+ packages, respectively.
+<tt>gs-gpl</tt>, +imagemagick+ and +pngcrush+ packages, respectively.
 
 == usage
 
@@ -29,26 +50,36 @@ The simplest way to use +minicomic+ is to create a +Rakefile+ as follows:
 
   minicomic '.'
 
-+minicomic+ will look for pages in a +pages/+ folder in the given directory
-(in this particular case, '.' meaning the directory where the +Rakefile+ lives).
++minicomic+ will look for pages in a <tt>pages/</tt> folder in the given
+directory (in this particular case, '.' meaning the directory where the
++Rakefile+ lives).  Options can be included after the directory name, for
+instance:
 
-+minicomic+ looks for SVG files in +pages/+ named according to the following
-conventions:
+  minicomic '.', :color => false
 
-+page-NN.svg+:: page NN
-+front-cover.svg+:: the front cover of the comic (optional)
-+back-cover.svg+:: the back cover of the comic (optional)
-+inside-front.svg+:: the inside front cover of the comic (optional)
-+inside-back.svg+:: the inside back cover of the comic (optional)
+(specific options will be discussed later)
 
-It is also possible to have two-page spreads in single files:
+In the pages directory, +minicomic+ looks for SVG files named according to the
+following conventions:
 
-+pages-NN-MM.svg+:: the spread spanning pages NN-MM
-+cover.svg+:: the cover (back and front together in one file; optional)
+<tt>page-NN.svg</tt>:: page +NN+
+<tt>front-cover.svg</tt>:: the front cover of the comic (optional)
+<tt>back-cover.svg</tt>:: the back cover of the comic (optional)
+<tt>inside-front.svg</tt>:: the inside front cover of the comic (optional)
+<tt>inside-back.svg</tt>:: the inside back cover of the comic (optional)
 
 Page numbers start at 1 (page 1 is a right-handed page, and the first
-interior page).  Page documents should be 5.5x8.5in or smaller for single
-pages, and 11x8.5in for two-page spreads.
+interior page excluding the inside cover).  The exact size of page documents
+is not important; they will be scaled to fit the selected output format
+(preserving aspect ratio).
+
+It is also possible to have two-page spreads in single files:
+
+<tt>pages-NN-MM.svg</tt>:: the spread spanning pages <tt>NN</tt>-<tt>MM</tt>
+<tt>cover.svg</tt>:: the cover (back and front together in one file; optional)
+
+A two-page spread will be cut in half and each half placed on the appropriate
+page in the print output.
 
 == print output
 
@@ -57,50 +88,96 @@ interior pages up to the next multiple of four, padding with blank pages
 as needed.  The page graphics will be scaled down slightly from their full
 size, and smaller graphics will be centered.
 
+=== print-related options
+
+There are several options which control how minicomic's print output is
+generated:
+
+<tt>:format</tt>:: the format for the folded booklet; options are <tt>:half_letter</tt>, <tt>:a5</tt>, <tt>:b5</tt>, or a two-element array with dimensions in postscript points (default: <tt>:half_letter</tt>)
+<tt>:rasterize</tt>:: whether print output should be rasterized rather than being exported as PostScript -- PostScript will usually result in smaller files, but cannot support many Inkscape features like blur or transparency (default: +true+)
+<tt>:margin</tt>:: a nominal horizontal margin in PostScript points; the page images will be scaled down slightly to accomodate this margin (default: +13.5+, which is 3/16 of an inch)
+
+The required paper format will be the double the booklet's format, so
+<tt>:half_letter</tt> requires US letter paper, <tt>:a5</tt>
+requires A4 paper, and <tt>:b5</tt> requires B4 paper.
+
+If the pages are rasterized, then the following options also apply to print:
+
+<tt>:color</tt>:: <tt>true</tt>, <tt>false</tt>, or <tt>:monochrome</tt> -- whether the rasterized images should be full-color, greyscale, or monochrome (24-bit color, 8-bit greyscale, or 1-bit bitmap) (default: <tt>true</tt>)
+<tt>:dpi</tt>:: the target DPI for the rasterized page images (taking into account any scaling to accomodate the margins) (default: +200+)
+
+=== proof output
+
 To generate a "proof" PDF that you can examine to see what spreads will
-look like in the assembled comic, use:
+look like in the assembled comic (i.e. "reader spreads"), use:
 
- +rake proof+
+ rake proof
 
-The PDF will be created as +print/proof.pdf+.  Since I rarely use the
-inside covers for anything, +minicomic+ places the front and back covers
-opposite the first and last interior pages respectively.
+The PDF will be created as <tt>print/proof.pdf</tt>.  Since I rarely use the
+inside covers for anything, +minicomic+ currently places the front and back
+covers opposite the first and last interior pages respectively.
 
-To generate a set of PDFs suitable for printing and assembly, use:
+=== single-sided printing
 
- +rake print+
+To generate a set of PDFs suitable for single-sided printing and assembly, use:
 
-This will generate a set of three PDFs:
+  rake single
 
-+print/duplex.pdf+:: suitable for duplex printing
-+print/front.pdf+ and +print/back.pdf+:: front and back sides for single-sided printing
+This will generate a set of two PDFs:
 
-If you are using a duplex printer, if you're lucky it will deposit its
-output pages face-up and they will be ready for assembly (this is the norm).
-Otherwise if it deposits its pages face-down, you will have reverse them before
-you can assemble the comic.
+<tt>print/front.pdf</tt>:: front side of all pages
+<tt>print/back.pdf</tt>:: back side of all pages
 
 When using the single-sided PDFs, _you will need to experiment_ to find the
 correct order to use them in, and the correct way to flip the paper.  For my
-printer, I print +back.pdf+ first, then flip the stack the long way before
-printing +front.pdf+ on it.  Other printers will differ depending on how the
-paper is loaded in the tray, and how it is stacked on output.
+printer, I print <tt>back.pdf</tt> first, then flip the stack the long way
+before printing <tt>front.pdf</tt> on it.  Other printers will differ depending
+on how the paper is loaded in the tray, and how it is stacked on output.
+
+=== duplex printing
+
+To generate a set of PDFs suitable for duplex printing and assembly, use:
+
+  rake duplex
+
+This will generate a single PDF, <tt>print/duplex.pdf</tt>.
+
+When printing this PDF, if you're lucky, your printer it will deposit its
+output pages face-down and they will be ready for assembly (this is the norm).
+Otherwise if it deposits its pages face-up, you will have reverse their order
+before you can assemble the comic.
 
 == web output
 
 You can generate files for web upload via:
 
- +rake web+
+ rake web
+
+=== web-related options
+
+The following options apply to web output:
 
-When generating output for the web, +minicomic+ will generate a set of 4-bit
-greyscale PNGs, and a corresponding set of JPEG thumbnails:
+<tt>:web_height</tt>:: the height, in pixels, of images for web output (width will be determined according to the page's aspect ratio) (default: 680)
+<tt>:thumbnail_height</tt>:: the height, in pixels, of thumbnail images (default: 96)
+<tt>:color</tt>:: whether the generated images should be 24-bit color (+true+), 8-bit greyscale (+false+), or 4-bit greyscale (<tt>:monochrome</tt>) (default: <tt>true</tt>)
 
-+web/page-NN.png+:: page NN
-+web/thumbnail-NN.jpeg:: thumbnail of page NN
+=== output files
+
+When generating output for the web, +minicomic+ will generate a set of PNGs
+and a corresponding set of JPEG thumbnails:
+
+<tt>web/page-NN.png</tt>:: page +NN+
+<tt>web/thumbnail-NN.jpeg</tt>:: thumbnail of page +NN+
+
+For spreads, the filenames are similar, except instead of a single page number
++NN+, a page range will be indicated as <tt>NN-MM</tt>.
 
 == cleanup
 
 You can easily get rid of the temporary and output files with:
 
- +rake clean+
+ rake clean
+
+This is often a good idea if you've changed any of minicomic's options, since
+files generated with the previous options may still be lingering.
 

data/Rakefile

@@ -18,7 +18,7 @@ end
 gemspec = Gem::Specification.new do |gemspec|
   gemspec.platform = Gem::Platform::RUBY
   gemspec.name = "minicomic"
-  gemspec.version = "0.0.1"
+  gemspec.version = "0.2"
   gemspec.author = "MenTaLguY <mental@rydia.net>"
   gemspec.summary = "Rake rules for minicomic impressions"
   gemspec.test_file = 'test/test_all.rb'
@@ -27,6 +27,7 @@ gemspec = Gem::Specification.new do |gemspec|
   gemspec.has_rdoc = true
   gemspec.extra_rdoc_files = %w(README)
   gemspec.rdoc_options = %w(--main README)
+  gemspec.add_dependency 'rake', '>= 0.7.0'
 end
 
 task :package => [ :test ]

data/lib/minicomic.rb

@@ -9,44 +9,114 @@
 require 'set'
 require 'rake'
 
-module Minicomic
-extend self
+class Minicomic
 
-private
+DEFAULT_OPTIONS = {
+  :rasterize => true,
+
+  :margin => 13.5,
+  :dpi => 200,
+
+  :color => true,
+
+  :format => :half_letter,
+
+  # in pixels
+  :web_height => 680,
+  :thumbnail_height => 96
+}
 
-# in PostScript points
-FORMAT_WIDTH = ( 5.5 * 72 ).to_i
-FORMAT_HEIGHT = ( 8.5 * 72 ).to_i
-PAGE_SCALE = 0.932
+private
 
-# other constants
+# constants
 LEFT = 0
 RIGHT = 1
 PHI = ( 1 + Math.sqrt( 5 ) ) / 2
 
+module Common
+  def get_ps_bbox( filename )
+    result = nil
+    File.open( filename, "r" ) do |stream|
+      magic = stream.gets.chomp
+      break unless magic =~ /^%!PS-Adobe/
+      stream.each_line do |line|
+        case line
+        when /^%%BoundingBox: (\d+) (\d+) (\d+) (\d+)/
+          result = [ ($1.to_f)..($3.to_f), ($2.to_f)..($4.to_f) ]
+          break
+        when /^%%EndComments/
+          break
+        end
+      end
+    end
+    raise RuntimeError, "unable to get bbox for #{ filename }" unless result
+    result
+  end
+
+  def get_generic_bbox( filename )
+    IO.popen("-", "r") do |stream|
+      if stream
+        line = stream.gets
+        if line
+          line.chomp.split.map { |n| 0.0..(n.to_f) }
+        else
+          raise RuntimeError, "unable to get bbox for #{ filename }"
+        end
+      else
+        begin
+          sh "identify", "-format", "%w %h", filename
+        rescue Exception => e
+          e.display
+        end
+        exit! 127
+      end
+    end
+  end
+
+  def get_bbox( filename )
+    case filename
+    when /\.e?ps$/i
+      get_ps_bbox( filename )
+    else
+      get_generic_bbox( filename )
+    end
+  end
+
+  def scale_print_page( width, height )
+    width_scale = @options[:format_width].to_f / width
+    height_scale = @options[:format_height].to_f / height
+    if width * height_scale > @options[:format_width]
+      width_scale
+    else
+      height_scale
+    end * @options[:scale]
+  end
+end
+include Common
+
 def eps_from_svg( eps_file, svg_file )
   file eps_file => [ svg_file ] do
     sh 'inkscape', '-T', '-B', '-E', eps_file, svg_file
   end
 end
 
-def back_eps( out_file, in_file )
+def back_ps( out_file, in_file )
   file out_file => [ in_file ] do
     sh 'psselect', '-e', in_file, out_file
   end
 end
 
-def front_eps( out_file, in_file )
+def front_ps( out_file, in_file )
   file out_file => [ in_file ] do
     sh 'psselect', '-o', in_file, out_file
   end
 end
 
 def make2up( in_file, out_file )
-  sh 'psnup', "-W#{ FORMAT_WIDTH }", "-H#{ FORMAT_HEIGHT }", "-h#{ FORMAT_WIDTH * 2 }", "-w#{ FORMAT_HEIGHT }", '-2', in_file, out_file
+  sh 'psnup', "-W#{ @options[:format_width].round }", "-H#{ @options[:format_height].round }", "-h#{ ( @options[:format_width] * 2 ).round }", "-w#{ @options[:format_height].round }", '-2', in_file, out_file
 end
 
-def duplex_eps( out_file, in_file )
+def duplex_ps( out_file, in_file )
   temp_file = "#{ out_file }.temp"
   file out_file => [ in_file ] do
     sh 'psbook', in_file, temp_file
@@ -58,7 +128,7 @@ def duplex_eps( out_file, in_file )
   end
 end
 
-def proof_eps( out_file, in_file )
+def proof_ps( out_file, in_file )
   temp_file = "#{ out_file }.temp"
   file out_file => [ in_file ] do
     sh 'psselect', '-p1,3-_3,_1', in_file, temp_file
@@ -70,32 +140,64 @@ def proof_eps( out_file, in_file )
   end
 end
 
-def pdf_from_eps( pdf_file, eps_file )
-  file pdf_file => [ eps_file ] do
-    sh 'ps2pdf', '-sPAPERSIZE=letter', eps_file, pdf_file
+def pdf_from_ps( pdf_file, ps_file )
+  file pdf_file => [ ps_file ] do
+    sh 'gs', '-q', '-dSAFER', '-dNOPAUSE', '-dBATCH', '-sDEVICE=pdfwrite', "-sOutputFile=#{ pdf_file }", '-dAutoRotatePages=/None', '-c', "<< /PageSize [#{ @options[:format_height].round } #{ ( @options[:format_width] * 2 ).round }] /Orientation 3 >> setpagedevice", '-c', '.setpdfwrite', '-f', ps_file
   end
 end
 
-def png_from_svg( png_file, svg_file )
+def png_from_svg( png_file, svg_file, high_res, &height_calc )
   temp_png_file = "#{ png_file }.temp"
   file png_file => [ svg_file ] do
-    sh 'inkscape', '-d', '80', '-C', '-y', '1.0', '-e', temp_png_file, svg_file
+    height = height_calc.call svg_file
+    sh 'inkscape', '-h', height.to_s, '-C', '-y', '1.0', '-e', temp_png_file, svg_file
     begin
-      sh 'pngcrush', '-force', '-bit_depth', '4', '-c', '0', '-q', temp_png_file, png_file
+      args = '-q', '-rem', 'allb'
+      case @options[:color]
+      when :color, true
+        args.push '-c', '2'
+      when :greyscale, :grayscale, false
+        args.push '-c', '0', '-bit_depth', '8'
+      when :monochrome
+        args.push '-c', '0', '-bit_depth', ( high_res ? '1' : '4' )
+      end
+      args.push temp_png_file, png_file
+      sh 'pngcrush', *args
+    rescue Exception
+      rm png_file if File.exist? png_file
+      raise
     ensure
       rm temp_png_file
     end
   end
 end
 
+def web_png_from_svg( png_file, svg_file )
+  png_from_svg( png_file, svg_file, false ) { @options[:web_height] }
+end
+
+def print_png_from_svg( png_file, splits, svg_file )
+  png_from_svg( png_file, svg_file, @options[:dpi] > 150 ) do |filename|
+    dims = get_bbox( filename ).map { |r| r.end - r.begin }
+    scale = scale_print_page( dims[0] / splits, dims[1] )
+    ( dims[1].to_f * scale * @options[:dpi] / 72 ).round
+  end
+end
+
 def thumbnail_jpeg_from_image( jpeg_file, image_file )
   file jpeg_file => [ image_file ] do
-    sh 'convert', '-filter', 'sinc', '-resize', "x96", image_file, jpeg_file
+    sh 'convert', '-filter', 'sinc', '-resize', "x#{ @options[:thumbnail_height] }", image_file, jpeg_file
   end
 end
 
+ImageSlice = Struct.new :n, :total, :filename
+PageSpec = Struct.new :bbox, :scale, :dims, :filename
+
 class BookletLayout
-  def initialize( stream, *pages )
+  include Common
+
+  def initialize( options, stream, *pages )
+    @options = options
     @bboxes = {}
     @stream = stream
 
@@ -122,37 +224,35 @@ class BookletLayout
   def format_pages( is_cover, *pages )
     spread = pages.map do |page|
       if page
-        [ bbox(*page), page[2] ]
-      else
-        nil
-      end
-    end.map do |page|
-      if page
-        bbox, document = page
-        dims = (0..1).map { |d| ( bbox[d].end - bbox[d].begin ) * PAGE_SCALE }
-        [ bbox, dims, document ]
+        bounds = bbox( page )
+        dims = (0..1).map { |d| bounds[d].end - bounds[d].begin }
+        scale = scale_print_page( *dims )
+        PageSpec[ bounds, scale, dims.map { |n| n * scale }, page.filename ]
       else
         nil
       end
     end
 
     if spread.all? # i.e. both?
-      spread_dims = spread.map { |page| page[1] }
-      left_document = spread[LEFT][2]
-      right_document = spread[RIGHT][2]
-      if left_document == right_document
+      spread_dims = spread.map { |page| page.dims }
+
+      if spread[LEFT].filename == spread[RIGHT].filename
         tx = translate_spread( *spread_dims )
       elsif is_cover
         tx = spread_dims.map { |dims| translate_single( dims ) }
       else
         tx = translate_facing( *spread_dims )
       end
-      [ [ spread[LEFT][0], tx[LEFT], left_document ],
-        [ spread[RIGHT][0], tx[RIGHT], right_document ] ]
+
+      [ LEFT, RIGHT ].map do |side|
+        [ spread[side].bbox, spread[side].scale, tx[side],
+          spread[side].filename ]
+      end
     else
       spread.map do |page|
         if page
-          [ page[0], translate_single( page[1] ), page[2] ]
+          [ page.bbox, page.scale, translate_single( page.dims ),
+            page.filename ]
         else
           nil
         end
@@ -160,32 +260,18 @@ class BookletLayout
     end
   end
 
-  def bbox( i, n, document )
-    rx, ry = @bboxes[document] ||= (
-      rx, ry = 0.0..(FORMAT_WIDTH.to_f * n), 0.0..(FORMAT_HEIGHT.to_f)
-      File.open( document, "r" ) do |stream|
-        stream.each_line do |line|
-          case line
-          when /^%%BoundingBox: (\d+) (\d+) (\d+) (\d+)/
-            rx, ry = ($1.to_f)..($3.to_f), ($2.to_f)..($4.to_f)
-            break
-          when /^%%EndComments/
-            break
-          end
-        end
-      end
-      [ rx, ry ]
-    )
+  def bbox( page )
+    rx, ry = @bboxes[page.filename] ||= get_bbox( page.filename )
     width = rx.end - rx.begin
-    [ ( rx.begin + width * i / n )..( rx.begin + width * ( i + 1 ) / n ), ry ]
+    [ ( rx.begin + width * page.n / page.total )..( rx.begin + width * ( page.n + 1 ) / page.total ), ry ]
   end
 
   def bottom_margin( height )
-    ( FORMAT_HEIGHT.to_f - height ) / PHI
+    ( @options[:format_height].to_f - height ) / PHI
   end
 
   def horizontal_margin( width )
-    ( FORMAT_WIDTH.to_f - width ) / 2
+    ( @options[:format_width].to_f - width ) / 2
   end
 
   def translate_single( dims )
@@ -201,7 +287,7 @@ class BookletLayout
   end
 
   def translate_spread( left, right )
-    [ [ FORMAT_WIDTH.to_f - left[0], bottom_margin( left[1] ) ],
+    [ [ @options[:format_width].to_f - left[0], bottom_margin( left[1] ) ],
       [ 0, bottom_margin( right[1] ) ] ]
   end
 
@@ -218,7 +304,7 @@ class BookletLayout
     emit_dsc 'Creator', 'minicomic'
     emit_dsc 'Pages', pages.size
     #emit_dsc 'Orientation', 'Portrait'
-    #bbox = "0 0 #{ FORMAT_WIDTH } #{ FORMAT_HEIGHT }"
+    #bbox = "0 0 #{ @options[:format_width].round } #{ @options[:format_height].round }"
     #emit_dsc 'BoundingBox', bbox
     #emit_dsc 'HiResBoundingBox', bbox
     emit_dsc 'EndComments'
@@ -241,21 +327,37 @@ class BookletLayout
     @stream.puts "closepath eoclip newpath"
   end
 
-  def emit_page( n, bbox, translate, document )
+  def emit_page( n, bbox, scale, translate, document )
     emit_dsc 'Page', "#{ n } #{ n }"
 
     @stream.puts "save"
-
-    emit_clip_rect( 0, 0, FORMAT_WIDTH, FORMAT_HEIGHT )
+    @stream.puts "/showpage {} def"
+    emit_clip_rect( 0, 0, @options[:format_width].round, @options[:format_height].round )
 
     @stream.puts <<EOS
-#{ bbox.map { |r| -r.begin }.join( ' ' ) } translate 
-#{ PAGE_SCALE } #{ PAGE_SCALE } scale
 #{ translate.join( ' ' ) } translate
+#{ scale } #{ scale } scale
 EOS
 
-    emit_clip_rect( bbox[0].begin, bbox[1].begin, bbox[0].end, bbox[1].end )
+    emit_embedded_page( bbox, document )
+
+    @stream.puts "restore"
+    @stream.puts "showpage"
+    emit_dsc 'PageTrailer'
+  end
+
+  def emit_embedded_page( bbox, document )
+    case document
+    when /\.e?ps$/i
+      emit_embedded_page_eps( bbox, document )
+    else
+      emit_embedded_page_generic( bbox, document )
+    end
+  end
 
+  def emit_embedded_page_eps( bbox, document )
+    @stream.puts "#{ bbox.map { |r| -r.begin }.join( ' ' ) } translate"
+    emit_clip_rect( bbox[0].begin, bbox[1].begin, bbox[0].end, bbox[1].end )
     emit_dsc 'BeginDocument', File.basename( document )
     File.open( document, 'r' ) do |input|
       input.each_line do |line|
@@ -263,8 +365,25 @@ EOS
       end
     end
     emit_dsc 'EndDocument'
-    emit_dsc 'PageTrailer'
-    @stream.puts "restore"
+  end
+
+  def emit_embedded_page_generic( bbox, document )
+    emit_dsc 'BeginDocument', File.basename( document )
+    IO.popen( "-", "r" ) do |input|
+      if input
+        input.each_line do |line|
+          @stream.puts line
+        end
+      else
+        begin
+          sh "convert", "-extract", "#{ ( bbox[0].end - bbox[0].begin ).round }x#{ ( bbox[1].end - bbox[1].begin ).round }+#{ bbox[0].begin.round }+#{ bbox[1].begin.round }", document, "eps:-"
+        rescue Exception => e
+          e.display
+        end
+        exit! 127
+      end
+    end
+    emit_dsc 'EndDocument'
   end
 
   def emit_empty_page( n )
@@ -274,10 +393,10 @@ EOS
 end
 
 def layout_booklet( layout_ps, *pages )
-  file layout_ps => pages.compact.map { |i, n, file| file } do
+  file layout_ps => pages.compact.map { |page| page.filename } do
     begin
       File.open( layout_ps, 'w' ) do |stream|
-        BookletLayout.new( stream, *pages )
+        BookletLayout.new( @options, stream, *pages )
       end
     rescue
       rm layout_ps
@@ -286,7 +405,8 @@ def layout_booklet( layout_ps, *pages )
   end
 end
 
-def special_name_re( name )
+SPECIAL_NAMES = %w(front-cover back-cover cover inside-front inside-back)
+SPECIAL_NAME_RES = SPECIAL_NAMES.map do |name|
   Regexp.new( Regexp.quote( name ).gsub( /-/, "\\W*" ), "i" )
 end
 
@@ -297,12 +417,28 @@ def normalize_special_name( name )
   name
 end
 
-SPECIAL_NAMES = %w(front-cover back-cover cover inside-front inside-back)
-SPECIAL_NAME_RES = SPECIAL_NAMES.map { |n| special_name_re( n ) }
+def initialize( dir, options={} )
+  @options = DEFAULT_OPTIONS.merge options
+
+  case @options[:format]
+  when :half_letter
+    @options[:format_width] = 5.5 * 72
+    @options[:format_height] = 8.5 * 72
+  when :a5
+    @options[:format_width] = 148 * 72 / 25.4
+    @options[:format_height] = 210 * 72 / 25.4
+  when :b5
+    @options[:format_width] = 176 * 72 / 25.4
+    @options[:format_height] = 250 * 72 / 25.4
+  when Array
+    @options[:format_width] = @options[:format][0].to_f
+    @options[:format_height] = @options[:format][1].to_f
+  else
+    raise ArgumentError, "Unknown booklet size #{ @options[:format] }"
+  end
 
-public
+  @options[:scale] = ( @options[:format_width] - ( @options[:margin] * 2.0 ) ) / @options[:format_width]
 
-def minicomic( dir )
   pages_dir = File.join( dir, 'pages' )
 
   scratch_dir = File.join( dir, 'scratch' )
@@ -319,6 +455,12 @@ def minicomic( dir )
   specials = Set.new
   pages = []
 
+  if @options[:rasterize]
+    print_ext = 'png'
+  else
+    print_ext = 'eps'
+  end
+
   FileList[File.join( pages_dir, '*.svg' )].each do |page_svg|
     name = File.basename( page_svg )
     name.sub!( /\.svg$/, '' )
@@ -352,21 +494,30 @@ def minicomic( dir )
       next
     end
 
-    page_eps = File.join( scratch_dir, "#{ print_name }.eps" )
+    print_file = File.join( scratch_dir, "#{ print_name }.#{ print_ext }" )
 
-    if min and min > 0
+    if min
       size = max - min + 1
-      (0...size).each do |n|
-        pages[n+min-1] = [ n, size, page_eps ]
+      if min > 0
+        (0...size).each do |n|
+          pages[n+min-1] = ImageSlice[ n, size, print_file ]
+        end
       end
+    else
+      size = 1
     end
 
-    eps_from_svg( page_eps, page_svg )
-    task page_eps => [ scratch_dir ]
+    case print_ext
+    when 'png'
+      print_png_from_svg( print_file, size, page_svg )
+    when 'eps'
+      eps_from_svg( print_file, page_svg )
+    end
+    task print_file => [ scratch_dir ]
 
     if web_name
       page_png = File.join( web_dir, "#{ web_name }.png" )
-      png_from_svg( page_png, page_svg )
+      web_png_from_svg( page_png, page_svg )
       task page_png => [ web_dir ]
       
       thumbnail_name = web_name.sub( /^page/, 'thumbnail' )
@@ -378,49 +529,54 @@ def minicomic( dir )
     end
   end
 
-  pages = [ nil, nil ] + pages + [ nil ] * ( pages.size % 4 ) + [ nil, nil ]
+  pages = [ nil, nil ] +
+          pages + [ nil ] * ( ( 4 - pages.size % 4 ) % 4 ) +
+          [ nil, nil ]
 
   specials.each do |name|
-    filename = File.join( scratch_dir, "#{ name }.eps" )
+    filename = File.join( scratch_dir, "#{ name }.#{ print_ext }" )
     case name
     when 'front-cover'
-      pages[0] ||= [ 0, 1, filename ] # 'cover' takes precedence
+      pages[0] ||= ImageSlice[ 0, 1, filename ] # 'cover' takes precedence
     when 'back-cover'
-      pages[-1] ||= [ 0, 1, filename ] # 'cover' takes precedence
+      pages[-1] ||= ImageSlice[ 0, 1, filename ] # 'cover' takes precedence
     when 'cover'
-      pages[-1] = [ 0, 2, filename ]
-      pages[0] = [ 1, 2, filename ]
+      pages[-1] = ImageSlice[ 0, 2, filename ]
+      pages[0] = ImageSlice[ 1, 2, filename ]
     when 'inside-front'
-      pages[1] = [ 0, 1, filename ]
+      pages[1] = ImageSlice[ 0, 1, filename ]
     when 'inside-back'
-      pages[-2] = [ 0, 1, filename ]
+      pages[-2] = ImageSlice[ 0, 1, filename ]
     end
   end
 
   layout_booklet( layout_ps, *pages )
 
-  duplex_eps = File.join( scratch_dir, "duplex.eps" )
+  duplex_ps = File.join( scratch_dir, "duplex.ps" )
 
   %w(proof back front duplex).each do |kind|
     case kind
     when 'duplex', 'proof'
       source = layout_ps
     else
-      source = duplex_eps
+      source = duplex_ps
     end 
-    kind_eps = File.join( scratch_dir, "#{ kind }.eps" )
-    send( "#{ kind }_eps", kind_eps, source )
-    task kind_eps => [ scratch_dir ]
+    kind_ps = File.join( scratch_dir, "#{ kind }.ps" )
+    send( "#{ kind }_ps", kind_ps, source )
+    task kind_ps => [ scratch_dir ]
     kind_pdf = File.join( print_dir, "#{ kind }.pdf" )
-    pdf_from_eps( kind_pdf, kind_eps )
+    pdf_from_ps( kind_pdf, kind_ps )
     task kind_pdf => [ print_dir ]
     task kind => [ kind_pdf ]
   end
 
-  desc "Generate PDF files for printing"
-  task :print => [ :duplex, :front, :back ]
+  desc "Generate PDF file for duplex printing"
+  task :duplex
 
-  desc "Generate a proof PDF for review"
+  desc "Generate PDF files for single-sided printing"
+  task :single => [ :front, :back ]
+
+  desc "Generate PDF file for review of reader spreads"
   task :proof
 
   desc "Remove all output and intermediate files"
@@ -433,15 +589,13 @@ def minicomic( dir )
   desc "Generate graphics for the web"
   task :web
 
-  desc "Generate web and print output"
-  task :both => [ :print, :web ]
-
-  task :default => [ :both ]
+  desc "All print and web output"
+  task :all => [ :proof, :duplex, :single, :web ]
 end
 
 end
 
-def minicomic( dir )
-  Minicomic.minicomic( dir )
+def minicomic( dir, options={} )
+  Minicomic.new( dir, options )
 end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: minicomic
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2007-03-29 00:00:00 -04:00
+  version: "0.2"
+date: 2007-04-21 00:00:00 -04:00
 summary: Rake rules for minicomic impressions
 require_paths: 
 - lib
@@ -45,5 +45,13 @@ extensions: []
 
 requirements: []
 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.7.0
+    version: