fireinc-pdf-reader 0.11.0.alpha

data/lib/pdf/reader/page.rb

@@ -0,0 +1,185 @@
+# coding: utf-8
+
+module PDF
+  class Reader
+
+    # high level representation of a single PDF page. Ties together the various
+    # low level classes in PDF::Reader and provides access to the various
+    # components of the page (text, images, fonts, etc) in convenient formats.
+    #
+    # If you require access to the raw PDF objects for this page, you can access
+    # the Page dictionary via the page_object accessor. You will need to use the
+    # objects accessor to help walk the page dictionary in any useful way.
+    #
+    class Page
+
+      # lowlevel hash-like access to all objects in the underlying PDF
+      attr_reader :objects
+
+      # the raw PDF object that defines this page
+      attr_reader :page_object
+
+      # 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)
+        @objects, @pagenum = objects, pagenum
+        @page_object = objects.deref(objects.page_references[pagenum - 1])
+
+        unless @page_object.is_a?(::Hash)
+          raise ArgumentError, "invalid page: #{pagenum}"
+        end
+      end
+
+      # return the number of this page within the full document
+      #
+      def number
+        @pagenum
+      end
+
+      # return a friendly string representation of this page
+      #
+      def inspect
+        "<PDF::Reader::Page page: #{@pagenum}>"
+      end
+
+      # Returns the attributes that accompany this page. Includes
+      # attributes inherited from parents.
+      #
+      def attributes
+        hash = {}
+        page_with_ancestors.reverse.each do |obj|
+          hash.merge!(@objects.deref(obj))
+        end
+        hash
+      end
+
+      # Returns the resources that accompany this page. Includes
+      # resources inherited from parents.
+      #
+      def resources
+        @resources ||= @objects.deref(attributes[:Resources]) || {}
+      end
+
+      # Returns the XObjects that are available to this page
+      #
+      def xobjects
+        resources[:XObject] || {}
+      end
+
+      # return a hash of fonts used on this page.
+      #
+      # The keys are the font labels used within the page content stream.
+      #
+      # The values are a PDF::Reader::Font instances that provide access
+      # to most available metrics for each font.
+      #
+      def fonts
+        raw_fonts = objects.deref(resources[:Font] || {})
+        ::Hash[raw_fonts.map { |label, font|
+          [label, PDF::Reader::Font.new(objects, objects.deref(font))]
+        }]
+      end
+
+      # returns the plain text content of this page encoded as UTF-8. Any
+      # characters that can't be translated will be returned as a ▯
+      #
+      def text
+        receiver = PageTextReceiver.new
+        walk(receiver)
+        receiver.content
+      end
+      alias :to_s :text
+
+      # processes the raw content stream for this page in sequential order and
+      # passes callbacks to the receiver objects.
+      #
+      # This is mostly low level and you can probably ignore it unless you need
+      # access to soemthing like the raw encoded text. For an example of how
+      # this can be used as a basis for higher level functionality, see the
+      # text() method
+      #
+      # If someone was motivated enough, this method is intended to provide all
+      # the data required to faithfully render the entire page. If you find
+      # some required data isn't available it's a bug - let me know.
+      #
+      # Many operators that generate callbacks will reference resources stored
+      # in the page header - think images, fonts, etc. To facilitate these
+      # operators, the first available callback is page=. If your receiver
+      # accepts that callback it will be passed the current
+      # PDF::Reader::Page object. Use the Page#resources method to grab any
+      # required resources.
+      #
+      def walk(*receivers)
+        callback(receivers, :page=, [self])
+        content_stream(receivers, raw_content)
+      end
+
+      # returns the raw content stream for this page. This is plumbing, nothing to
+      # see here unless you're a PDF nerd like me.
+      #
+      def raw_content
+        contents = objects.deref(@page_object[:Contents])
+        [contents].flatten.compact.map { |obj|
+          objects.deref(obj)
+        }.map { |obj|
+          obj.unfiltered_data
+        }.join
+      end
+
+      private
+
+      def root
+        root ||= objects.deref(@objects.trailer[:Root])
+      end
+
+      def content_stream(receivers, instructions)
+        buffer       = Buffer.new(StringIO.new(instructions), :content_stream => true)
+        parser       = Parser.new(buffer, @objects)
+        params       = []
+
+        while (token = parser.parse_token(PagesStrategy::OPERATORS))
+          if token.kind_of?(Token) and PagesStrategy::OPERATORS.has_key?(token)
+            callback(receivers, PagesStrategy::OPERATORS[token], params)
+            params.clear
+          else
+            params << token
+          end
+        end
+      rescue EOFError => e
+        raise MalformedPDFError, "End Of File while processing a content stream"
+      end
+
+      # calls the name callback method on the receiver class with params as the arguments
+      #
+      def callback (receivers, name, params=[])
+        receivers.each do |receiver|
+          receiver.send(name, *params) if receiver.respond_to?(name)
+        end
+      end
+
+      def page_with_ancestors(obj = nil)
+        obj = objects.deref(obj)
+        if obj.nil?
+          [@page_object] + page_with_ancestors(@page_object[:Parent])
+        elsif obj[:Parent]
+          [select_inheritable(obj)] + page_with_ancestors(obj[:Parent])
+        else
+          [select_inheritable(obj)]
+        end
+      end
+
+      # select the elements from a Pages dictionary that can be inherited by
+      # child Page dictionaries.
+      #
+      def select_inheritable(obj)
+        ::Hash[obj.select { |key, value|
+          [:Resources, :MediaBox, :CropBox, :Rotate, :Parent].include?(key)
+        }]
+      end
+
+    end
+  end
+end

data/lib/pdf/reader/page_text_receiver.rb

@@ -0,0 +1,278 @@
+# coding: utf-8
+
+require 'matrix'
+require 'yaml'
+
+module PDF
+  class Reader
+    class PageTextReceiver
+
+      DEFAULT_GRAPHICS_STATE = {
+        :ctm          => Matrix.identity(3),
+        :char_spacing => 0,
+        :word_spacing => 0,
+        :h_scaling    => 100,
+        :text_leading => 0,
+        :text_font    => nil,
+        :text_font_size => nil,
+        :text_mode    => 0,
+        :text_rise    => 0,
+        :text_knockout => 0
+      }
+
+      # starting a new page
+      def page=(page)
+        @page    = page
+        @objects = page.objects
+        @fonts   = page.fonts
+        @form_fonts = {}
+        @content = ::Hash.new
+        @stack   = [DEFAULT_GRAPHICS_STATE]
+      end
+
+      def content
+        keys = @content.keys.sort.reverse
+        keys.map { |key|
+          @content[key]
+        }.join("\n")
+      end
+
+      #####################################################
+      # Graphics State Operators
+      #####################################################
+
+      def save_graphics_state
+        @stack.push clone_state
+      end
+
+      def restore_graphics_state
+        @stack.pop
+      end
+
+      #####################################################
+      # Matrix Operators
+      #####################################################
+
+      # update the current transformation matrix.
+      #
+      # If the CTM is currently undefined, just store the new values.
+      #
+      # If there's an existing CTM, then multiply the existing matrix
+      # 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]
+        else
+          state[:ctm] = transform
+        end
+      end
+
+      #####################################################
+      # Text Object Operators
+      #####################################################
+
+      def begin_text_object
+        @text_matrix      = Matrix.identity(3)
+        @text_line_matrix = Matrix.identity(3)
+      end
+
+      def end_text_object
+        @text_matrix      = Matrix.identity(3)
+        @text_line_matrix = Matrix.identity(3)
+      end
+
+      #####################################################
+      # Text State Operators
+      #####################################################
+
+      def set_character_spacing(char_spacing)
+        state[:char_spacing] = char_spacing
+      end
+
+      def set_horizontal_text_scaling(h_scaling)
+        state[:h_scaling] = h_scaling
+      end
+
+      def set_text_font_and_size(label, size)
+        state[:text_font]      = label
+        state[:text_font_size] = size
+      end
+
+      def set_text_leading(leading)
+        state[:text_leading] = leading
+      end
+
+      def set_text_rendering_mode(mode)
+        state[:text_mode] = mode
+      end
+
+      def set_text_rise(rise)
+        state[:text_rise] = rise
+      end
+
+      def set_word_spacing(word_spacing)
+        state[:word_spacing] = word_spacing
+      end
+
+      #####################################################
+      # Text Positioning Operators
+      #####################################################
+
+      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
+      end
+
+      def move_text_position_and_set_leading(x, y) # TD
+        set_text_leading(-1 * y)
+        move_text_position(x, y)
+      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]
+                            ]
+      end
+
+      def move_to_start_of_next_line # T*
+        move_text_position(0, state[:text_leading])
+      end
+
+      #####################################################
+      # Text Showing Operators
+      #####################################################
+
+      # record text that is drawn on the page
+      def show_text(string) # Tj
+        at = transform(Point.new(0,0))
+        @content[at.y] ||= ""
+        @content[at.y] << current_font.to_utf8(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
+        }
+      end
+
+      def move_to_next_line_and_show_text(str) # '
+        move_to_start_of_next_line
+        show_text(str)
+      end
+
+      def set_spacing_next_line_show_text(aw, ac, string) # "
+        set_word_spacing(aw)
+        set_character_spacing(ac)
+        move_to_next_line_and_show_text(string)
+      end
+
+      #####################################################
+      # XObjects
+      #####################################################
+      def invoke_xobject(label)
+        save_graphics_state
+        xobject = @objects.deref(@page.xobjects[label])
+
+        matrix = xobject.hash[:Matrix]
+        concatenate_matrix(*matrix) if matrix
+
+        if xobject.hash[:Subtype] == :Form
+          form = PDF::Reader::FormXObject.new(@page, xobject)
+          @form_fonts = form.fonts
+          form.walk(self)
+        end
+        @form_fonts = {}
+
+        restore_graphics_state
+      end
+
+      private
+
+      # transform x and y co-ordinates from the current text space to the
+      # underlying device space.
+      #
+      def transform(point, z = 1)
+        trm = text_rendering_matrix
+        Point.new(
+          (trm[0,0] * point.x) + (trm[1,0] * point.y) + (trm[2,0] * z),
+          (trm[0,1] * point.x) + (trm[1,1] * point.y) + (trm[2,1] * z)
+        )
+      end
+
+      def text_rendering_matrix
+        state_matrix = Matrix[
+                         [state[:text_font_size] * state[:h_scaling], 0, 0],
+                         [0, state[:text_font_size], 0],
+                         [0, state[:text_rise], 1]
+                       ]
+
+        state_matrix * @text_matrix * ctm
+      end
+
+      def state
+        @stack.last
+      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.
+      #
+      # YAML 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
+          yaml_state = YAML.dump(@stack.last)
+          YAML.load(yaml_state)
+        end
+      end
+
+      # return the current transformation matrix
+      #
+      def ctm
+        state[:ctm]
+      end
+
+      def current_font
+        @form_fonts[state[:text_font]] || @fonts[state[:text_font]]
+      end
+
+      # private class for representing points on a cartesian plain. Used
+      # to simplify maths in the MinPpi class.
+      #
+      class Point
+        attr_reader :x, :y
+
+        def initialize(x,y)
+          @x, @y = x,y
+        end
+
+        def distance(point)
+          Math.hypot(point.x - x, point.y - y)
+        end
+      end
+    end
+  end
+end