hexapdf 0.1.0

data/lib/hexapdf/content/parser.rb

@@ -0,0 +1,204 @@
+# -*- encoding: utf-8 -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2016 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#++
+
+require 'stringio'
+require 'hexapdf/tokenizer'
+
+module HexaPDF
+  module Content
+
+    # More efficient tokenizer for content streams. This tokenizer class works directly on a
+    # string and not on an IO.
+    #
+    # Note: Indirect object references are *not* supported by this tokenizer!
+    #
+    # See: PDF1.7 s7.2
+    class Tokenizer < HexaPDF::Tokenizer #:nodoc:
+
+      # Creates a new tokenizer.
+      def initialize(string)
+        @ss = StringScanner.new(string)
+      end
+
+      # See: HexaPDF::Tokenizer#pos
+      def pos
+        @ss.pos
+      end
+
+      # See: HexaPDF::Tokenizer#pos=
+      def pos=(pos)
+        @ss.pos = pos
+      end
+
+      # See: HexaPDF::Tokenizer#scan_until
+      def scan_until(re)
+        @ss.scan_until(re)
+      end
+
+      # See: HexaPDF::Tokenizer#next_token
+      def next_token
+        @ss.skip(WHITESPACE_MULTI_RE)
+        case (@ss.eos? ? -1 : @ss.string.getbyte(@ss.pos))
+        when 43, 45, 46, 48..57 # + - . 0..9
+          parse_number
+        when 65..90, 96..121
+          parse_keyword
+        when 47 # /
+          parse_name
+        when 40 # (
+          parse_literal_string
+        when 60 # <
+          if @ss.string.getbyte(@ss.pos + 1) != 60
+            parse_hex_string
+          else
+            @ss.pos += 2
+            TOKEN_DICT_START
+          end
+        when 62 # >
+          unless @ss.string.getbyte(@ss.pos + 1) == 62
+            raise HexaPDF::MalformedPDFError.new("Delimiter '>' found at invalid position", pos: pos)
+          end
+          @ss.pos += 2
+          TOKEN_DICT_END
+        when 91 # [
+          @ss.pos += 1
+          TOKEN_ARRAY_START
+        when 93 # ]
+          @ss.pos += 1
+          TOKEN_ARRAY_END
+        when 123, 125 # { }
+          Token.new(@ss.get_byte)
+        when 37 # %
+          return NO_MORE_TOKENS unless @ss.skip_until(/(?=[\r\n])/)
+          next_token
+        when -1
+          NO_MORE_TOKENS
+        else
+          parse_keyword
+        end
+      end
+
+      private
+
+      # See: HexaPDF::Tokenizer#parse_number
+      def parse_number
+        if (val = @ss.scan(/[+-]?\d++(?!\.)/))
+          val.to_i
+        else
+          val = @ss.scan(/[+-]?(?:\d+\.\d*|\.\d+)/)
+          val << '0'.freeze if val.getbyte(-1) == 46 # dot '.'
+          Float(val)
+        end
+      end
+
+      # Stub implementation to prevent errors for not-overridden methods.
+      def prepare_string_scanner(*)
+      end
+
+    end
+
+
+    # This class knows how to correctly parse a content stream.
+    #
+    # == Overview
+    #
+    # A content stream is mostly just a stream of PDF objects. However, there is one exception:
+    # inline images.
+    #
+    # Since inline images don't follow the normal PDF object parsing rules, they need to be
+    # handled specially and this is the reason for this class. Therefore only the BI operator is
+    # ever called for inline images because the ID and EI operators are handled by the parser.
+    #
+    # To parse some contents the #parse method needs to be called with the contents to be parsed
+    # and a Processor object which is used for processing the parsed operators.
+    class Parser
+
+      # Creates a new Parser object and calls #parse.
+      def self.parse(contents, processor)
+        new.parse(contents, processor)
+      end
+
+      # Parses the contents and calls the processor object for each parsed operator.
+      def parse(contents, processor)
+        tokenizer = Tokenizer.new(contents)
+        params = []
+        while (obj = tokenizer.next_object(allow_keyword: true)) != Tokenizer::NO_MORE_TOKENS
+          if obj.kind_of?(Tokenizer::Token)
+            if obj == 'BI'.freeze
+              params = parse_inline_image(tokenizer)
+            end
+            processor.process(obj.to_sym, params)
+            params.clear
+          else
+            params << obj
+          end
+        end
+      end
+
+      private
+
+      # Parses the inline image at the current position.
+      def parse_inline_image(tokenizer)
+        # BI has already been read, so read the image dictionary
+        dict = {}
+        while (key = tokenizer.next_object(allow_keyword: true))
+          if key == 'ID'.freeze
+            break
+          elsif key == Tokenizer::NO_MORE_TOKENS
+            raise HexaPDF::Error, "EOS while trying to read dictionary key for inline image"
+          elsif !key.kind_of?(Symbol)
+            raise HexaPDF::Error, "Inline image dictionary keys must be PDF name objects"
+          end
+          value = tokenizer.next_object
+          if value == Tokenizer::NO_MORE_TOKENS
+            raise HexaPDF::Error, "EOS while trying to read dictionary value for inline image"
+          end
+          dict[key] = value
+        end
+
+        # one whitespace character after ID
+        tokenizer.next_byte
+
+        # find the EI operator
+        data = tokenizer.scan_until(/(?=EI[#{Tokenizer::WHITESPACE}])/o)
+        if data.nil?
+          raise HexaPDF::Error, "End inline image marker EI not found"
+        end
+        tokenizer.pos += 3
+        [dict, data]
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/content/processor.rb

@@ -0,0 +1,451 @@
+# -*- encoding: utf-8 -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2016 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#++
+
+require 'hexapdf/content/operator'
+require 'hexapdf/content/graphics_state'
+
+module HexaPDF
+  module Content
+
+    # This class is used for processing content operators extracted from a content stream.
+    #
+    # == General Information
+    #
+    # When a content stream is read, operators and their operands are extracted. After extracting
+    # these operators are normally processed with a Processor instance that ensures that the needed
+    # setup (like modifying the graphics state) is done before further processing.
+    #
+    # == How Processing Works
+    #
+    # The operator implementations (see the Operator module) are called first and they ensure that
+    # the processing state is consistent. For example, operators that modify the graphics state do
+    # actually modify the #graphics_state object. However, operator implementations are *only* used
+    # for this task and not more, so they are very specific and normally don't need to be changed.
+    #
+    # After that methods corresponding to the operator names are invoked on the processor object (if
+    # they exist). Each PDF operator name is mapped to a nicer message name via the
+    # OPERATOR_MESSAGE_NAME_MAP constant. For example, the operator 'q' is mapped to
+    # 'save_graphics_state".
+    #
+    # The task of these methods is to do something useful with the content itself, it doesn't need
+    # to concern itself with ensuring the consistency of the processing state. For example, the
+    # processor could use the processing state to extract the text. Or paint the content on a
+    # canvas.
+    #
+    # For inline images only the 'BI' operator mapped to 'inline_image' is used. Although also the
+    # operators 'ID' and 'EI' exist for inline images, they are not used because they are consumed
+    # while parsing inline images and do not reflect separate operators.
+    #
+    # == Text Processing
+    #
+    # Two utility methods #decode_text and #decode_text_with_positioning for extracting text are
+    # provided. Both can directly be invoked from the 'show_text' and 'show_text_with_positioning'
+    # methods.
+    #
+    class Processor
+
+      # Represents an (immutable) glyph box with positioning information.
+      #
+      # Since the glyph may have been transformed by an affine matrix, the bounding may not be a
+      # rectangle in all cases but it is always a parallelogram.
+      class GlyphBox
+
+        # The code point representing the glyph.
+        attr_reader :code_point
+
+        # The Unicode value of the code point.
+        attr_reader :string
+
+        # Creates a new glyph box for the given code point/Unicode value pair with the lower left
+        # coordinate [llx, lly], the lower right coordinate [lrx, lry], and the upper left
+        # coordinate [ulx, uly].
+        def initialize(code_point, string, llx, lly, lrx, lry, ulx, uly)
+          @code_point = code_point
+          @string = string.freeze
+          @llx = llx
+          @lly = lly
+          @lrx = lrx
+          @lry = lry
+          @ulx = ulx
+          @uly = uly
+          freeze
+        end
+
+        # :call-seq:
+        #   fragment.lower_left    -> [llx, lly]
+        #
+        # Returns the lower left coordinate
+        def lower_left
+          [@llx, @lly]
+        end
+
+        # :call-seq:
+        #    fragment.lower_right   -> [lrx, lry]
+        #
+        # Returns the lower right coordinate
+        def lower_right
+          [@lrx, @lry]
+        end
+
+        # :call-seq:
+        #    fragment.upper_left    -> [ulx, uly]
+        #
+        # Returns the upper left coordinate
+        def upper_left
+          [@ulx, @uly]
+        end
+
+        # :call-seq:
+        #    fragment.upper_right    -> [urx, ury]
+        #
+        # Returns the upper right coordinate which is computed by using the other three points of
+        # the parallelogram.
+        def upper_right
+          [@ulx + (@lrx - @llx), @uly + (@lry - @lly)]
+        end
+
+        # :call-seq:
+        #    fragment.points         -> [llx, lly, lrx, lry, urx, ury, ulx, uly]
+        #
+        # Returns the four corners of the box as an array of coordinates, starting with the lower
+        # left corner and going counterclockwise.
+        def points
+          [@llx, @lly, @lrx, @lry, @ulx + (@lrx - @llx), @uly + (@lry - @lly), @ulx, @uly]
+        end
+
+      end
+
+
+      # Represents a box composed of GlyphBox objects.
+      #
+      # The bounding box methods #lower_left, #lower_right, #upper_left, #upper_right are computed
+      # by just using the first and last boxes, assuming the boxes are arranged from left to right
+      # in a straight line.
+      class CompositeBox
+
+        # The text boxes contained in this positioned text object.
+        attr_reader :boxes
+
+        # Creates an empty object.
+        def initialize
+          @boxes = []
+        end
+
+        # Appends the given text glyph box.
+        def <<(glyph_box)
+          @boxes << glyph_box
+          self
+        end
+
+        # Returns the glyph box at the given index, or +nil+ if the index is out of range.
+        def [](index)
+          @boxes[index]
+        end
+
+        # :call-seq:
+        #   composite.each {|glyph_box| block}       -> composite
+        #   composite.each                           -> Enumerator
+        #
+        # Iterates over all contained glyph boxes.
+        def each(&block)
+          return to_enum(__method__) unless block_given?
+          @boxes.each(&block)
+          self
+        end
+
+        # Returns the concatenated text of the boxes.
+        def string
+          @boxes.map(&:string).join('')
+        end
+
+        # :call-seq:
+        #   text.lower_left    -> [llx, lly]
+        #
+        # Returns the lower left coordinate
+        def lower_left
+          @boxes[0].lower_left
+        end
+
+        # :call-seq:
+        #    text.lower_right   -> [lrx, lry]
+        #
+        # Returns the lower right coordinate
+        def lower_right
+          @boxes[-1].lower_right
+        end
+
+        # :call-seq:
+        #    text.upper_left    -> [ulx, uly]
+        #
+        # Returns the upper left coordinate
+        def upper_left
+          @boxes[0].upper_left
+        end
+
+        # :call-seq:
+        #    text.upper_right    -> [urx, ury]
+        #
+        # Returns the upper right coordinate.
+        def upper_right
+          @boxes[-1].upper_right
+        end
+
+      end
+
+      # Mapping of PDF operator names to message names that are sent to renderer implementations.
+      OPERATOR_MESSAGE_NAME_MAP = {
+        q: :save_graphics_state,
+        Q: :restore_graphics_state,
+        cm: :concatenate_matrix,
+        w: :set_line_width,
+        J: :set_line_cap_style,
+        j: :set_line_join_style,
+        M: :set_miter_limit,
+        d: :set_line_dash_pattern,
+        ri: :set_rendering_intent,
+        i: :set_flatness_tolerance,
+        gs: :set_graphics_state_parameters,
+        CS: :set_stroking_color_space,
+        cs: :set_non_stroking_color_space,
+        SC: :set_stroking_color,
+        SCN: :set_stroking_color,
+        sc: :set_non_stroking_color,
+        scn: :set_non_stroking_color,
+        G: :set_device_gray_stroking_color,
+        g: :set_device_gray_non_stroking_color,
+        RG: :set_device_rgb_stroking_color,
+        rg: :set_device_rgb_non_stroking_color,
+        K: :set_device_cmyk_stroking_color,
+        k: :set_device_cmyk_non_stroking_color,
+        m: :move_to,
+        l: :line_to,
+        c: :curve_to,
+        v: :curve_to_no_first_control_point,
+        y: :curve_to_no_second_control_point,
+        h: :close_subpath,
+        re: :append_rectangle,
+        S: :stroke_path,
+        s: :close_and_stroke_path,
+        f: :fill_path_non_zero,
+        F: :fill_path_non_zero,
+        'f*'.to_sym => :fill_path_even_odd,
+        B: :fill_and_stroke_path_non_zero,
+        'B*'.to_sym => :fill_and_stroke_path_even_odd,
+        b: :close_fill_and_stroke_path_non_zero,
+        'b*'.to_sym => :close_fill_and_stroke_path_even_odd,
+        n: :end_path,
+        W: :clip_path_non_zero,
+        'W*'.to_sym => :clip_path_even_odd,
+        BT: :begin_text,
+        ET: :end_text,
+        Tc: :set_character_spacing,
+        Tw: :set_word_spacing,
+        Tz: :set_horizontal_scaling,
+        TL: :set_leading,
+        Tf: :set_font_and_size,
+        Tr: :set_text_rendering_mode,
+        Ts: :set_text_rise,
+        Td: :move_text,
+        TD: :move_text_and_set_leading,
+        Tm: :set_text_matrix,
+        'T*'.to_sym => :move_text_next_line,
+        Tj: :show_text,
+        '\''.to_sym => :move_text_next_line_and_show_text,
+        '"'.to_sym => :set_spacing_move_text_next_line_and_show_text,
+        TJ: :show_text_with_positioning,
+        d0: :set_glyph_width, # only for Type 3 fonts
+        d1: :set_glyph_width_and_bounding_box, # only for Type 3 fonts
+        sh: :paint_shading,
+        BI: :inline_image, # ID and EI are not sent because the complete image has been read
+        Do: :paint_xobject,
+        MP: :designate_marked_content_point,
+        DP: :designate_marked_content_point_with_property_list,
+        BMC: :begin_marked_content,
+        BDC: :begin_marked_content_with_property_list,
+        EMC: :end_marked_content,
+        BX: :begin_compatibility_section,
+        EX: :end_compatibility_section,
+      }
+
+      # Mapping from operator name (Symbol) to a callable object.
+      #
+      # This hash is prepopulated with the default operator implementations (see
+      # Operator::DEFAULT_OPERATORS). If a default operator implementation is not satisfactory, it
+      # can easily be changed by modifying this hash.
+      attr_reader :operators
+
+      # The resources dictionary used during processing.
+      attr_accessor :resources
+
+      # The GraphicsState object containing the current graphics state.
+      #
+      # It is not advised that this attribute is changed manually, it is automatically adjusted
+      # according to the processed operators!
+      attr_reader :graphics_state
+
+      # The current graphics object.
+      #
+      # It is not advised that this attribute is changed manually, it is automatically adjusted
+      # according to the processed operators!
+      #
+      # This attribute can have the following values:
+      #
+      # :none:: No current graphics object, i.e. the processor is at the page description level.
+      # :path:: The current graphics object is a path.
+      # :clipping_path:: The current graphics object is a clipping path.
+      # :text:: The current graphics object is text.
+      #
+      # See: PDF1.7 s8.2
+      attr_accessor :graphics_object
+
+      # Initializes a new processor that uses the resources PDF dictionary for resolving resources
+      # while processing operators.
+      #
+      # It is not mandatory to set the resources dictionary on initialization but it needs to be set
+      # prior to processing operators!
+      def initialize(resources = nil)
+        @operators = Operator::DEFAULT_OPERATORS.dup
+        @graphics_state = GraphicsState.new
+        @resources = resources
+        @graphics_object = :none
+      end
+
+      # Processes the operator with the given operands.
+      #
+      # The operator is first processed with an operator implementation (if any) to ensure correct
+      # operations and then the corresponding method on this object is invoked.
+      def process(operator, operands = [])
+        @operators[operator].invoke(self, *operands) if @operators.key?(operator)
+        msg = OPERATOR_MESSAGE_NAME_MAP[operator]
+        send(msg, *operands) if msg && respond_to?(msg, true)
+      end
+
+      protected
+
+      # Provides a default implementation for the 'Do' operator.
+      #
+      # It checks if the XObject is a Form XObject and if so, processes the contents of the Form
+      # XObject.
+      def paint_xobject(name)
+        xobject = resources.xobject(name)
+        return unless xobject[:Subtype] == :Form
+
+        res = resources
+        graphics_state.save
+
+        graphics_state.ctm.premultiply(*xobject[:Matrix]) if xobject.key?(:Matrix)
+        xobject.process_contents(self)
+
+        graphics_state.restore
+        self.resources = res
+      end
+
+      # Decodes the given text object and returns it as UTF-8 string.
+      #
+      # The argument may either be a simple text string (+Tj+ operator) or an array that contains
+      # text strings together with positioning information (+TJ+ operator).
+      def decode_text(data)
+        if data.kind_of?(Array)
+          data = data.each_with_object(''.b) {|obj, result| result << obj if obj.kind_of?(String)}
+        end
+        font = graphics_state.font
+        font.decode(data).map {|code_point| font.to_utf8(code_point)}.join('')
+      end
+
+      # Decodes the given text object and returns it as a CompositeBox object.
+      #
+      # The argument may either be a simple text string (+Tj+ operator) or an array that contains
+      # text strings together with positioning information (+TJ+ operator).
+      #
+      # For each glyph a GlyphBox object is computed. For horizontal fonts the width is
+      # predetermined but not the height. The latter is chosen to be the height and offset of the
+      # font's bounding box.
+      def decode_text_with_positioning(data)
+        data = Array(data)
+        if graphics_state.font.writing_mode == :horizontal
+          decode_horizontal_text(data)
+        else
+          decode_vertical_text(data)
+        end
+      end
+
+      private
+
+      # Decodes the given array containing text and positioning information while assuming that the
+      # writing direction is horizontal.
+      #
+      # See: PDF1.7 s9.4.4
+      def decode_horizontal_text(array)
+        font = graphics_state.font
+        scaled_char_space = graphics_state.scaled_character_spacing
+        scaled_word_space = graphics_state.scaled_word_spacing
+        scaled_font_size = graphics_state.scaled_font_size
+
+        below_baseline = font.bounding_box[1] * scaled_font_size / \
+          graphics_state.scaled_horizontal_scaling + graphics_state.text_rise
+        above_baseline = font.bounding_box[3] * scaled_font_size / \
+          graphics_state.scaled_horizontal_scaling + graphics_state.text_rise
+
+        text = CompositeBox.new
+        array.each do |item|
+          if item.kind_of?(Numeric)
+            graphics_state.tm.translate(-item * scaled_font_size, 0)
+          else
+            font.decode(item).each do |code_point|
+              char = font.to_utf8(code_point)
+              width = font.width(code_point) * scaled_font_size
+              matrix = graphics_state.ctm.dup.premultiply(*graphics_state.tm)
+              fragment = GlyphBox.new(code_point, char,
+                                      *matrix.evaluate(0, below_baseline),
+                                      *matrix.evaluate(width, below_baseline),
+                                      *matrix.evaluate(0, above_baseline))
+              text << fragment
+              graphics_state.tm.translate(width + scaled_char_space + \
+                                          (char == ' ' ? scaled_word_space : 0), 0)
+            end
+          end
+        end
+
+        text.freeze
+      end
+
+      # Decodes the given array containing text and positioning information while assuming that the
+      # writing direction is vertical.
+      def decode_vertical_text(_data)
+        raise NotImplementedError
+      end
+
+    end
+
+  end
+end