pdf-reader 1.2.0 → 1.3.0

data/lib/pdf/reader/page_state.rb

@@ -1,22 +1,23 @@
 # coding: utf-8
 
-require 'matrix'
+require 'pdf/reader/transformation_matrix'
 
-module PDF
-  class Reader
+class PDF::Reader
+    # encapsulates logic for tracking graphics state as the instructions for
+    # a single page are processed. Most of the public methods correspond
+    # directly to PDF operators.
     class PageState
 
       DEFAULT_GRAPHICS_STATE = {
-        :ctm          => Matrix.identity(3),
-        :char_spacing => 0,
-        :word_spacing => 0,
-        :h_scaling    => 100,
-        :text_leading => 0,
-        :text_font    => nil,
+        :char_spacing   => 0,
+        :word_spacing   => 0,
+        :h_scaling      => 1.0,
+        :text_leading   => 0,
+        :text_font      => nil,
         :text_font_size => nil,
-        :text_mode    => 0,
-        :text_rise    => 0,
-        :text_knockout => 0
+        :text_mode      => 0,
+        :text_rise      => 0,
+        :text_knockout  => 0
       }
 
       # starting a new page
@@ -28,16 +29,23 @@ module PDF
         @xobject_stack = [page.xobjects]
         @cs_stack      = [page.color_spaces]
         @stack         = [DEFAULT_GRAPHICS_STATE.dup]
+        state[:ctm]    = identity_matrix
       end
 
       #####################################################
       # Graphics State Operators
       #####################################################
 
+      # Clones the current graphics state and push it onto the top of the stack.
+      # Any changes that are subsequently made to the state can then by reversed
+      # by calling restore_graphics_state.
+      #
       def save_graphics_state
         @stack.push clone_state
       end
 
+      # Restore the state to the previous value on the stack.
+      #
       def restore_graphics_state
         @stack.pop
       end
@@ -54,16 +62,12 @@ module PDF
       # with the new matrix to form the updated matrix.
       #
       def concatenate_matrix(a, b, c, d, e, f)
-        transform = Matrix[
-          [a, b, 0],
-          [c, d, 0],
-          [e, f, 1]
-        ]
         if state[:ctm]
-          state[:ctm] = transform * state[:ctm]
+          state[:ctm].multiply!(a,b,c,d,e,f)
         else
-          state[:ctm] = transform
+          state[:ctm] = TransformationMatrix.new(a,b,c,d,e,f)
         end
+        @text_rendering_matrix = nil # invalidate cached value
       end
 
       #####################################################
@@ -71,13 +75,13 @@ module PDF
       #####################################################
 
       def begin_text_object
-        @text_matrix      = Matrix.identity(3)
-        @text_line_matrix = Matrix.identity(3)
+        @text_matrix      = identity_matrix
+        @text_line_matrix = identity_matrix
+        @font_size = nil
       end
 
       def end_text_object
-        @text_matrix      = Matrix.identity(3)
-        @text_line_matrix = Matrix.identity(3)
+        # don't need to do anything
       end
 
       #####################################################
@@ -89,7 +93,7 @@ module PDF
       end
 
       def set_horizontal_text_scaling(h_scaling)
-        state[:h_scaling] = h_scaling
+        state[:h_scaling] = h_scaling / 100.0
       end
 
       def set_text_font_and_size(label, size)
@@ -98,7 +102,7 @@ module PDF
       end
 
       def font_size
-        state[:text_font_size] * @text_matrix[0,0]
+        @font_size ||= state[:text_font_size] * @text_matrix.a * ctm.a
       end
 
       def set_text_leading(leading)
@@ -122,12 +126,16 @@ module PDF
       #####################################################
 
       def move_text_position(x, y) # Td
-        temp_matrix = Matrix[
-          [1, 0, 0],
-          [0, 1, 0],
-          [x, y, 1]
-        ]
-        @text_matrix = @text_line_matrix = temp_matrix * @text_line_matrix
+        temp = TransformationMatrix.new(1, 0,
+                                        0, 1,
+                                        x, y)
+        @text_line_matrix = temp.multiply!(
+          @text_line_matrix.a, @text_line_matrix.b,
+          @text_line_matrix.c, @text_line_matrix.d,
+          @text_line_matrix.e, @text_line_matrix.f
+        )
+        @text_matrix = @text_line_matrix.dup
+        @font_size = @text_rendering_matrix = nil # invalidate cached value
       end
 
       def move_text_position_and_set_leading(x, y) # TD
@@ -136,11 +144,13 @@ module PDF
       end
 
       def set_text_matrix_and_text_line_matrix(a, b, c, d, e, f) # Tm
-        @text_matrix = @text_line_matrix = Matrix[
-          [a, b, 0],
-          [c, d, 0],
-          [e, f, 1]
-        ]
+        @text_matrix = TransformationMatrix.new(
+          a, b,
+          c, d,
+          e, f
+        )
+        @text_line_matrix = @text_matrix.dup
+        @font_size = @text_rendering_matrix = nil # invalidate cached value
       end
 
       def move_to_start_of_next_line # T*
@@ -197,22 +207,29 @@ module PDF
       # transform x and y co-ordinates from the current user space to the
       # underlying device space.
       #
-      def ctm_transform(x, y, z = 1)
+      def ctm_transform(x, y)
         [
-          (ctm[0,0] * x) + (ctm[1,0] * y) + (ctm[2,0] * z),
-          (ctm[0,1] * x) + (ctm[1,1] * y) + (ctm[2,1] * z)
+          (ctm.a * x) + (ctm.c * y) + (ctm.e),
+          (ctm.b * x) + (ctm.d * y) + (ctm.f)
         ]
       end
 
       # transform x and y co-ordinates from the current text space to the
       # underlying device space.
       #
-      def trm_transform(x, y, z = 1)
+      # transforming (0,0) is a really common case, so optimise for it to
+      # avoid unnecessary object allocations
+      #
+      def trm_transform(x, y)
         trm = text_rendering_matrix
-        [
-          (trm[0,0] * x) + (trm[1,0] * y) + (trm[2,0] * z),
-          (trm[0,1] * x) + (trm[1,1] * y) + (trm[2,1] * z)
-        ]
+        if x == 0 && y == 0
+          [trm.e, trm.f]
+        else
+          [
+            (trm.a * x) + (trm.c * y) + (trm.e),
+            (trm.b * x) + (trm.d * y) + (trm.f)
+          ]
+        end
       end
 
       def current_font
@@ -240,16 +257,105 @@ module PDF
         dict ? dict[label] : nil
       end
 
+      # when save_graphics_state is called, we need to push a new copy of the
+      # current state onto the stack. That way any modifications to the state
+      # will be undone once restore_graphics_state is called.
+      #
+      def stack_depth
+        @stack.size
+      end
+
+      # This returns a deep clone of the current state, ensuring changes are
+      # keep separate from earlier states.
+      #
+      # Marshal is used to round-trip the state through a string to easily
+      # perform the deep clone. Kinda hacky, but effective.
+      #
+      def clone_state
+        if @stack.empty?
+          {}
+        else
+          Marshal.load Marshal.dump(@stack.last)
+        end
+      end
+
+      # after each glyph is painted onto the page the text matrix must be
+      # modified. There's no defined operator for this, but depending on
+      # the use case some receivers may need to mutate the state with this
+      # while walking a page.
+      #
+      # NOTE: some of the variable names in this method are obscure because
+      #       they mirror variable names from the PDF spec
+      #
+      # NOTE: see Section 9.4.4, PDF 32000-1:2008, pp 252
+      #
+      # Arguments:
+      #
+      # w0 - the glyph width in *text space*. This generally means the width
+      #      in glyph space should be divded by 1000 before being passed to
+      #      this function
+      # tj - any kerning that should be applied to the text matrix before the
+      #      following glyph is painted. This is usually the numeric arguments
+      #      in the array passed to a TJ operator
+      # word_boundary - a boolean indicating if a word boundary was just
+      #                 reached. Depending on the current state extra space
+      #                 may need to be added
+      #
+      def process_glyph_displacement(w0, tj, word_boundary)
+        fs = font_size # font size
+        tc = state[:char_spacing]
+        if word_boundary
+          tw = state[:word_spacing]
+        else
+          tw = 0
+        end
+        th = state[:h_scaling]
+        # optimise the common path to reduce Float allocations
+        if th == 1 && tj == 0 && tc == 0 && tw == 0
+          glyph_width = w0 * fs
+          tx = glyph_width
+        else
+          glyph_width = ((w0 - (tj/1000.0)) * fs) * th
+          tx = glyph_width + ((tc + tw) * th)
+        end
+        ty = 0
+
+        # TODO: I'm pretty sure that tx shouldn't need to be divided by
+        #       ctm[0] here, but this gets my tests green and I'm out of
+        #       ideas for now
+        # TODO: support ty > 0
+        if ctm.a == 1
+          @text_matrix.horizontal_displacement_multiply!(tx)
+        else
+          @text_matrix.horizontal_displacement_multiply!(tx/ctm.a)
+        end
+        @font_size = @text_rendering_matrix = nil # invalidate cached value
+      end
+
       private
 
+      # used for many and varied text positioning calculations. We potentially
+      # need to access the results of this method many times when working with
+      # text, so memoize it
+      #
       def text_rendering_matrix
-        state_matrix = Matrix[
-          [font_size * state[:h_scaling], 0, 0],
-          [0, font_size, 0],
-          [0, state[:text_rise], 1]
-        ]
-
-        state_matrix * @text_matrix * ctm
+        @text_rendering_matrix ||= begin
+          state_matrix = TransformationMatrix.new(
+            font_size * state[:h_scaling], 0,
+            0, font_size,
+            0, state[:text_rise]
+          )
+          state_matrix.multiply!(
+            @text_matrix.a, @text_matrix.b,
+            @text_matrix.c, @text_matrix.d,
+            @text_matrix.e, @text_matrix.f
+          )
+          state_matrix.multiply!(
+            ctm.a, ctm.b,
+            ctm.c, ctm.d,
+            ctm.e, ctm.f
+          )
+        end
       end
 
       # return the current transformation matrix
@@ -272,25 +378,22 @@ module PDF
         ::Hash[wrapped_fonts]
       end
 
-      # when save_graphics_state is called, we need to push a new copy of the
-      # current state onto the stack. That way any modifications to the state
-      # will be undone once restore_graphics_state is called.
-      #
-      # This returns a deep clone of the current state, ensuring changes are
-      # keep separate from earlier states.
-      #
-      # Marshal is used to round-trip the state through a string to easily
-      # perform the deep clone. Kinda hacky, but effective.
-      #
-      def clone_state
-        if @stack.empty?
-          {}
-        else
-          Marshal.load Marshal.dump(@stack.last)
-        end
+      #####################################################
+      # Low-level Matrix Operations
+      #####################################################
+
+      # This class uses 3x3 matrices to represent geometric transformations
+      # These matrices are represented by arrays with 9 elements
+      # The array [a,b,c,d,e,f,g,h,i] would represent a matrix like:
+      #   a b c
+      #   d e f
+      #   g h i
+
+      def identity_matrix
+        TransformationMatrix.new(1, 0,
+                                 0, 1,
+                                 0, 0)
       end
 
     end
-  end
 end
-

data/lib/pdf/reader/page_text_receiver.rb

@@ -1,13 +1,22 @@
 # coding: utf-8
 
-require 'matrix'
 require 'forwardable'
+require 'pdf/reader/page_layout'
 
 module PDF
   class Reader
+
+    # Builds a UTF-8 string of all the text on a single page by processing all
+    # the operaters in a content stream.
+    #
     class PageTextReceiver
       extend Forwardable
 
+      SPACE = " "
+
+      attr_reader :state, :content, :options
+
+      ########## BEGIN FORWARDERS ##########
       # Graphics State Operators
       def_delegators :@state, :save_graphics_state, :restore_graphics_state
 
@@ -26,41 +35,32 @@ module PDF
       # Text Positioning Operators
       def_delegators :@state, :move_text_position, :move_text_position_and_set_leading
       def_delegators :@state, :set_text_matrix_and_text_line_matrix, :move_to_start_of_next_line
+      ##########  END FORWARDERS  ##########
 
       # starting a new page
       def page=(page)
         @state = PageState.new(page)
-        @content = {}
+        @content = []
+        @characters = []
+        @mediabox = page.attributes[:MediaBox]
       end
 
       def content
-        keys = @content.keys.sort.reverse
-        keys.map { |key|
-          @content[key]
-        }.join("\n")
+        PageLayout.new(@characters, @mediabox).to_s
       end
 
       #####################################################
       # Text Showing Operators
       #####################################################
-
       # record text that is drawn on the page
-      def show_text(string) # Tj
-        raise PDF::Reader::MalformedPDFError, "current font is invalid" if @state.current_font.nil?
-        newx, newy = @state.trm_transform(0,0)
-        @content[newy] ||= ""
-        @content[newy] << @state.current_font.to_utf8(string)
+      def show_text(string) # Tj (AWAY)
+        internal_show_text(string)
       end
 
-      def show_text_with_positioning(params) # TJ
-        params.each { |arg|
-          case arg
-          when String
-            show_text(arg)
-          when Fixnum, Float
-            show_text(" ") if arg > 1000
-          end
-        }
+      def show_text_with_positioning(params) # TJ [(A) 120 (WA) 20 (Y)]
+        params.each_slice(2).each do |string, kerning|
+          internal_show_text(string, kerning || 0)
+        end
       end
 
       def move_to_next_line_and_show_text(str) # '
@@ -86,6 +86,35 @@ module PDF
         end
       end
 
+      private
+
+      def internal_show_text(string, kerning = 0)
+        if @state.current_font.nil?
+          raise PDF::Reader::MalformedPDFError, "current font is invalid"
+        end
+        glyphs = @state.current_font.unpack(string)
+        glyphs.each_with_index do |glyph_code, index|
+          # paint the current glyph
+          newx, newy = @state.trm_transform(0,0)
+          utf8_chars = @state.current_font.to_utf8(glyph_code)
+
+          # apply to glyph displacment for the current glyph so the next
+          # glyph will appear in the correct position
+          glyph_width = @state.current_font.glyph_width(glyph_code) / 1000.0
+          th = 1
+          if kerning != 0 && index == glyphs.size - 1
+            tj = kerning
+          else
+            tj = 0
+          end
+          scaled_glyph_width = glyph_width * @state.font_size * th
+          unless utf8_chars == SPACE
+            @characters << TextRun.new(newx, newy, scaled_glyph_width, @state.font_size, utf8_chars)
+          end
+          @state.process_glyph_displacement(glyph_width, tj, utf8_chars == SPACE)
+        end
+      end
+
     end
   end
 end