pdf-reader 1.1.1 → 2.5.0

data/lib/pdf/reader/page.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 module PDF
   class Reader
@@ -20,17 +21,23 @@ module PDF
       # the raw PDF object that defines this page
       attr_reader :page_object
 
+      # a Hash-like object for storing cached data. Generally this is scoped to
+      # the current document and is used to avoid repeating expensive
+      # operations
+      attr_reader :cache
+
       # creates a new page wrapper.
       #
       # * objects - an ObjectHash instance that wraps a PDF file
       # * pagenum - an int specifying the page number to expose. 1 indexed.
       #
-      def initialize(objects, pagenum)
+      def initialize(objects, pagenum, options = {})
         @objects, @pagenum = objects, pagenum
         @page_object = objects.deref(objects.page_references[pagenum - 1])
+        @cache       = options[:cache] || {}
 
         unless @page_object.is_a?(::Hash)
-          raise ArgumentError, "invalid page: #{pagenum}"
+          raise InvalidPageError, "Invalid page: #{pagenum}"
         end
       end
 
@@ -55,6 +62,16 @@ module PDF
             hash.merge!(@objects.deref(obj))
           end
         }
+        # This shouldn't be necesary, but some non compliant PDFs leave MediaBox
+        # out. Assuming 8.5" x 11" is what Acobat does, so we do it too.
+        @attributes[:MediaBox] ||= [0,0,612,792]
+        @attributes
+      end
+
+      # Convenience method to identify the page's orientation.
+      #
+      def orientation
+        OrientationDetector.new(attributes).orientation
       end
 
       # returns the plain text content of this page encoded as UTF-8. Any
@@ -107,6 +124,34 @@ module PDF
         }.join(" ")
       end
 
+      # returns the angle to rotate the page clockwise. Always 0, 90, 180 or 270
+      #
+      def rotate
+        value = attributes[:Rotate].to_i
+        case value
+        when 0, 90, 180, 270
+          value
+        else
+          0
+        end
+      end
+
+      # returns the "boxes" that define the page object.
+      # values are defaulted according to section 7.7.3.3 of the PDF Spec 1.7
+      #
+      def boxes
+        mediabox = attributes[:MediaBox]
+        cropbox = attributes[:Cropbox] || mediabox
+
+        {
+          MediaBox: objects.deref!(mediabox),
+          CropBox: objects.deref!(cropbox),
+          BleedBox: objects.deref!(attributes[:BleedBox] || cropbox),
+          TrimBox: objects.deref!(attributes[:TrimBox] || cropbox),
+          ArtBox: objects.deref!(attributes[:ArtBox] || cropbox)
+        }
+      end
+
       private
 
       def root
@@ -139,7 +184,7 @@ module PDF
 
       # calls the name callback method on each receiver object with params as the arguments
       #
-      def callback (receivers, name, params=[])
+      def callback(receivers, name, params=[])
         receivers.each do |receiver|
           receiver.send(name, *params) if receiver.respond_to?(name)
         end

data/lib/pdf/reader/page_layout.rb

@@ -0,0 +1,125 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require 'pdf/reader/overlapping_runs_filter'
+
+class PDF::Reader
+
+  # Takes a collection of TextRun objects and renders them into a single
+  # string that best approximates the way they'd appear on a render PDF page.
+  #
+  # media box should be a 4 number array that describes the dimensions of the
+  # page to be rendered as described by the page's MediaBox attribute
+  class PageLayout
+
+    DEFAULT_FONT_SIZE = 12
+
+    def initialize(runs, mediabox)
+      raise ArgumentError, "a mediabox must be provided" if mediabox.nil?
+
+      @runs    = merge_runs(OverlappingRunsFilter.exclude_redundant_runs(runs))
+      @mean_font_size   = mean(@runs.map(&:font_size)) || DEFAULT_FONT_SIZE
+      @mean_font_size = DEFAULT_FONT_SIZE if @mean_font_size == 0
+      @mean_glyph_width = mean(@runs.map(&:mean_character_width)) || 0
+      @page_width  = (mediabox[2] - mediabox[0]).abs
+      @page_height = (mediabox[3] - mediabox[1]).abs
+      @x_offset = @runs.map(&:x).sort.first || 0
+      lowest_y = @runs.map(&:y).sort.first || 0
+      @y_offset = lowest_y > 0 ? 0 : lowest_y
+    end
+
+    def to_s
+      return "" if @runs.empty?
+      return "" if row_count == 0
+
+      page = row_count.times.map { |i| " " * col_count }
+      @runs.each do |run|
+        x_pos = ((run.x - @x_offset) / col_multiplier).round
+        y_pos = row_count - ((run.y - @y_offset) / row_multiplier).round
+        if y_pos <= row_count && y_pos >= 0 && x_pos <= col_count && x_pos >= 0
+          local_string_insert(page[y_pos-1], run.text, x_pos)
+        end
+      end
+      interesting_rows(page).map(&:rstrip).join("\n")
+    end
+
+    private
+
+    # given an array of strings, return a new array with empty rows from the
+    # beginning and end removed.
+    #
+    #   interesting_rows([ "", "one", "two", "" ])
+    #   => [ "one", "two" ]
+    #
+    def interesting_rows(rows)
+      line_lengths = rows.map { |l| l.strip.length }
+
+      return [] if line_lengths.all?(&:zero?)
+
+      first_line_with_text = line_lengths.index { |l| l > 0 }
+      last_line_with_text  = line_lengths.size - line_lengths.reverse.index { |l| l > 0 }
+      interesting_line_count = last_line_with_text - first_line_with_text
+      rows[first_line_with_text, interesting_line_count].map
+    end
+
+    def row_count
+      @row_count ||= (@page_height / @mean_font_size).floor
+    end
+
+    def col_count
+      @col_count ||= ((@page_width  / @mean_glyph_width) * 1.05).floor
+    end
+
+    def row_multiplier
+      @row_multiplier ||= @page_height.to_f / row_count.to_f
+    end
+
+    def col_multiplier
+      @col_multiplier ||= @page_width.to_f / col_count.to_f
+    end
+
+    def mean(collection)
+      if collection.size == 0
+        0
+      else
+        collection.inject(0) { |accum, v| accum + v} / collection.size.to_f
+      end
+    end
+
+    def each_line(&block)
+      @runs.sort.group_by { |run|
+        run.y.to_i
+      }.map { |y, collection|
+        yield y, collection
+      }
+    end
+
+    # take a collection of TextRun objects and merge any that are in close
+    # proximity
+    def merge_runs(runs)
+      runs.group_by { |char|
+        char.y.to_i
+      }.map { |y, chars|
+        group_chars_into_runs(chars.sort)
+      }.flatten.sort
+    end
+
+    def group_chars_into_runs(chars)
+      runs = []
+      while head = chars.shift
+        if runs.empty?
+          runs << head
+        elsif runs.last.mergable?(head)
+          runs[-1] = runs.last + head
+        else
+          runs << head
+        end
+      end
+      runs
+    end
+
+    def local_string_insert(haystack, needle, index)
+      haystack[Range.new(index, index + needle.length - 1)] = String.new(needle)
+    end
+  end
+end

data/lib/pdf/reader/page_state.rb

@@ -1,42 +1,52 @@
 # coding: utf-8
+# frozen_string_literal: true
 
-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
       def initialize(page)
         @page          = page
+        @cache         = page.cache
         @objects       = page.objects
         @font_stack    = [build_fonts(page.fonts)]
         @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
@@ -53,16 +63,17 @@ 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]
+          ctm = state[:ctm]
+          state[:ctm] = TransformationMatrix.new(a,b,c,d,e,f).multiply!(
+            ctm.a, ctm.b,
+            ctm.c, ctm.d,
+            ctm.e, ctm.f
+          )
         else
-          state[:ctm] = transform
+          state[:ctm] = TransformationMatrix.new(a,b,c,d,e,f)
         end
+        @text_rendering_matrix = nil # invalidate cached value
       end
 
       #####################################################
@@ -70,13 +81,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
 
       #####################################################
@@ -88,7 +99,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)
@@ -97,7 +108,11 @@ module PDF
       end
 
       def font_size
-        state[:text_font_size] * @text_matrix[0,0]
+        @font_size ||= begin
+                         _, zero = trm_transform(0,0)
+                         _, one  = trm_transform(1,1)
+                         (zero - one).abs
+                       end
       end
 
       def set_text_leading(leading)
@@ -121,12 +136,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
@@ -135,11 +154,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*
@@ -176,7 +197,7 @@ module PDF
         concatenate_matrix(*matrix) if matrix
 
         if xobject.hash[:Subtype] == :Form
-          form = PDF::Reader::FormXObject.new(@page, xobject)
+          form = PDF::Reader::FormXObject.new(@page, xobject, :cache => @cache)
           @font_stack.unshift(form.font_objects)
           @xobject_stack.unshift(form.xobjects)
           yield form if block_given?
@@ -196,22 +217,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
@@ -239,16 +267,106 @@ 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
+          tx = w0 * fs
+        elsif tj != 0
+          # don't apply spacing to TJ displacement
+          tx = (w0 - (tj/1000.0)) * fs * th
+        else
+          # apply horizontal scaling to spacing values but not font size
+          tx = ((w0 * fs) + tc + tw) * th
+        end
+
+        # 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 || ctm.a == 0
+          @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(
+            state[:text_font_size] * state[:h_scaling], 0,
+            0, state[:text_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
@@ -271,25 +389,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
-