iiif_print 1.0.0

data/lib/iiif_print/text_extraction/hocr_reader.rb

@@ -0,0 +1,172 @@
+require 'active_support/core_ext/module/delegation'
+require 'json'
+require 'nokogiri'
+
+module IiifPrint
+  # Module for text extraction
+  module TextExtraction
+    # Class to obtain plain text and JSON word-coordinates from hOCR source
+    #   - Coordinates in px units, unlike ALTO, which may have scaling concerns
+    class HOCRReader
+      attr_accessor :source, :doc_stream
+      delegate :text, :width, :height, :words, to: :doc_stream
+
+      # SAX Document Stream class to gather text and word tokens from hOCR
+      class HOCRDocStream < Nokogiri::XML::SAX::Document
+        attr_accessor :text, :words, :width, :height
+
+        def initialize
+          super()
+          # plain text buffer:
+          @text = ''
+          # list of word hash, containing word+coord:
+          @words = []
+          # page width and height to be found in hOCR for `div.ocr_page`
+          @width = nil
+          @height = nil
+          # to hold current word data state across #start_element, #characters,
+          #   and #end_element methods (to associate word with coordinates).
+          @current = nil
+          # to preserve element classname from start to use by #end_element
+          @element_class_name = nil
+        end
+
+        # Return coordinates from `span.ocrx_word` element attribute hash
+        #
+        # @param attrs [Hash] hash with hOCR `span.ocrx_word` element attributes
+        # @return [Array] Array of position x, y, width, height in px.
+        def s_coords(attrs)
+          element_title = attrs['title']
+          bbox = element_title.split(';')[0].split('bbox ')[-1]
+          x1, y1, x2, y2 = bbox.split(' ').map(&:to_i)
+          height = y2 - y1
+          width = x2 - x1
+          hpos = x1
+          vpos = y1
+          [hpos, vpos, width, height]
+        end
+
+        # Consider element for processing?
+        #   - `div.ocr_page` — to get page width/height
+        #   - `span.ocr_line` — to help make plain text readable
+        #   - `span.ocrx_word` — for word-coordinate JSON and plain text word
+        # @param name [String] Element name
+        # @param class_name [String] HTML class name
+        # @return [Boolean] true if element should be processed; otherwise false
+        def consider?(name, class_name)
+          selector = "#{name}.#{class_name}"
+          ['div.ocr_page', 'span.ocr_line', 'span.ocrx_word'].include?(selector)
+        end
+
+        def start_word(attrs)
+          @current = {}
+          # will be replaced during #characters method call:
+          @current[:word] = nil
+          @current[:coordinates] = s_coords(attrs)
+        end
+
+        def start_page(attrs)
+          title = attrs['title']
+          fields = title.split(';')
+          bbox = fields[1].split('bbox ')[-1].split(' ').map(&:to_i)
+          # width and height:
+          @width = bbox[2]
+          @height = bbox[3]
+        end
+
+        def word_complete?
+          return false if @current.nil?
+          coords = @current[:coordinates]
+          @current[:word] && !@current[:word].empty? && coords.size == 4
+        end
+
+        def end_word
+          # add trailing space to plaintext buffer for between words:
+          @text += ' '
+          @words.push(@current) if word_complete?
+        end
+
+        def end_line
+          # strip trailing whitespace
+          @text.strip!
+          # then insert a line break
+          @text += "\n"
+        end
+
+        # Callback for element start, ignores elements except for:
+        #   - `div.ocr_page` — to get page width/height
+        #   - `span.ocr_line` — to help make plain text readable
+        #   - `span.ocrx_word` — for word-coordinate JSON and plain text word
+        #
+        # @param name [String] element name.
+        # @param attrs [Array] Array of key, value pair Arrays.
+        def start_element(name, attrs = [])
+          attributes = attrs.to_h
+          @element_class_name = attributes['class']
+          return unless consider?(name, @element_class_name)
+          start_word(attributes) if @element_class_name == 'ocrx_word'
+          start_page(attributes) if @element_class_name == 'ocr_page'
+        end
+
+        def characters(value)
+          return if @current.nil?
+          return if @current[:coordinates].nil?
+          @current[:word] ||= ''
+          @current[:word] += value
+          @text += value
+        end
+
+        # Callback for element end; at this time, flush word coordinate state
+        #   for current word, and append line endings to plain text:
+        #
+        # @param name [String] element name.
+        def end_element(_name)
+          end_line if @element_class_name == 'ocr_line'
+          end_word if @element_class_name == 'ocrx_word'
+        end
+
+        # Callback for completion of parsing hOCR, used to normalize generated
+        #   text content (strip unneeded whitespace incidental to output).
+        def end_document
+          # postprocess @text to remove trailing spaces on lines
+          @text = @text.split("\n").map(&:strip).join("\n")
+          # remove excess line break
+          @text.gsub!(/\n+/, "\n")
+          @text.delete("\r")
+          # remove trailing whitespace at end of buffer
+          @text.strip!
+        end
+      end
+
+      # Construct with either path or HTML [String]
+      #
+      # @param html [String], and process document
+      def initialize(html)
+        @source = isxml?(html) ? html : File.read(html)
+        @doc_stream = HOCRDocStream.new
+        parser = Nokogiri::HTML::SAX::Parser.new(doc_stream)
+        parser.parse(@source)
+      end
+
+      # Determine if source parameter is path or xml/html
+      #
+      # @param xml [String] either path to xml file or xml source
+      # @return [true, false] true if value appears to be XML/HTML, not path
+      def isxml?(xml)
+        xml.lstrip.start_with?('<')
+      end
+
+      # Output JSON flattened word coordinates
+      #
+      # @return [String] JSON serialization of flattened word coordinates
+      def json
+        words = @doc_stream.words
+        IiifPrint::TextExtraction::WordCoordsBuilder.json_coordinates_for(
+          words: words,
+          width: @doc_stream.width,
+          height: @doc_stream.height
+        )
+      end
+    end
+  end
+end

data/lib/iiif_print/text_extraction/page_ocr.rb

@@ -0,0 +1,87 @@
+require 'json'
+require 'open3'
+require 'tmpdir'
+
+# --
+module IiifPrint
+  # Module for text extraction (OCR or otherwise)
+  module TextExtraction
+    class PageOCR
+      attr_accessor :html, :path
+
+      def initialize(path, additional_tessearct_options: IiifPrint.config.additional_tessearct_options)
+        @path = path
+        # hOCR html:
+        @html = nil
+        @words = nil
+        @source_meta = nil
+        @box = nil
+        @plain = nil
+        @additional_tessearct_options = additional_tessearct_options
+      end
+
+      def run_ocr
+        outfile = File.join(Dir.mktmpdir, 'output_html')
+        cmd = "tesseract #{path} #{outfile} hocr"
+        cmd += " #{@additional_tessearct_options}" if @additional_tessearct_options.present?
+        `#{cmd}`
+        outfile + '.hocr'
+      end
+
+      def load_words
+        preprocess_image
+        html_path = run_ocr
+        reader = IiifPrint::TextExtraction::HOCRReader.new(html_path)
+        @words = reader.words
+        @plain = reader.text
+      end
+
+      def words
+        load_words if @words.nil?
+        @words
+      end
+
+      def word_json
+        IiifPrint::TextExtraction::WordCoordsBuilder.json_coordinates_for(
+          words: words,
+          width: width,
+          height: height
+        )
+      end
+
+      def plain
+        load_words if @plain.nil?
+        @plain
+      end
+
+      def identify
+        return @source_meta unless @source_meta.nil?
+        @source_meta = IiifPrint::ImageTool.new(@path).metadata
+      end
+
+      def width
+        identify[:width]
+      end
+
+      def height
+        identify[:height]
+      end
+
+      def alto
+        writer = IiifPrint::TextExtraction::RenderAlto.new(width, height)
+        writer.to_alto(words)
+      end
+
+      private
+
+      # transform the image into a one-bit TIFF for OCR
+      def preprocess_image
+        tool = IiifPrint::ImageTool.new(@path)
+        return if tool.metadata[:color] == 'monochrome'
+        intermediate_path = File.join(Dir.mktmpdir, 'monochrome-interim.tif')
+        tool.convert(intermediate_path, true)
+        @path = intermediate_path
+      end
+    end
+  end
+end

data/lib/iiif_print/text_extraction/render_alto.rb

@@ -0,0 +1,84 @@
+require 'nokogiri'
+
+module IiifPrint
+  # Module for text extraction (OCR or otherwise)
+  module TextExtraction
+    class RenderAlto
+      def initialize(width, height, scaling = 1.0)
+        @height = height
+        @width = width
+        @scaling = scaling
+      end
+
+      def to_alto(words)
+        page = alto_page(@width, @height) do |xml|
+          words.each do |word|
+            xml.String(
+              CONTENT: word[:word],
+              WIDTH: scale_point(word[:coordinates][2]).to_s,
+              HEIGHT: scale_point(word[:coordinates][3]).to_s,
+              HPOS: scale_point(word[:coordinates][0]).to_s,
+              VPOS: scale_point(word[:coordinates][1]).to_s
+            ) { xml.text '' }
+          end
+        end
+        page.to_xml
+      end
+
+      private
+
+      # given block to manage word generation, wrap with page/block/line
+      def alto_page(pxwidth, pxheight, &block)
+        builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+          xml.alto(xmlns: 'http://www.loc.gov/standards/alto/ns-v2#') do
+            xml.Description do
+              xml.MeasurementUnit 'pixel'
+            end
+            alto_layout(xml, pxwidth, pxheight, &block)
+          end
+        end
+        builder
+      end
+
+      def scale_point(value)
+        # NOTE: presuming non-fractional, even though ALTO 2.1
+        #   specifies coordinates are xsd:float, not xsd:int,
+        #   simplify to integer value for output:
+        (value * @scaling).to_i
+      end
+
+      # return layout for page
+      def alto_layout(xml, pxwidth, pxheight, &block)
+        xml.Layout do
+          xml.Page(ID: 'ID1',
+                   PHYSICAL_IMG_NR: '1',
+                   HEIGHT: pxheight.to_i,
+                   WIDTH: pxwidth.to_i) do
+            xml.PrintSpace(HEIGHT: pxheight.to_i,
+                           WIDTH: pxwidth.to_i,
+                           HPOS: '0',
+                           VPOS: '0') do
+              alto_blockline(xml, pxwidth, pxheight, &block)
+            end
+          end
+        end
+      end
+
+      # make block line and call word-block
+      def alto_blockline(xml, pxwidth, pxheight)
+        xml.TextBlock(ID: 'ID1a',
+                      HEIGHT: pxheight.to_i,
+                      WIDTH: pxwidth.to_i,
+                      HPOS: '0',
+                      VPOS: '0') do
+          xml.TextLine(HEIGHT: pxheight.to_i,
+                       WIDTH: pxwidth.to_i,
+                       HPOS: '0',
+                       VPOS: '0') do
+            yield(xml)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iiif_print/text_extraction/word_coords_builder.rb

@@ -0,0 +1,38 @@
+module IiifPrint
+  # Module for text extraction (OCR or otherwise)
+  module TextExtraction
+    class WordCoordsBuilder
+      # @params words [Array<Hash>] an array of hash objects that have the keys `:word` and `:coordinates`.
+      # @params width [Integer] the width of the "canvas" on which the words appear.
+      # @params height [Integer] the height of the "canvas" on which the words appear.
+      # @return [String] a JSON encoded string.
+      def self.json_coordinates_for(words:, width: nil, height: nil)
+        new(words, width, height).to_json
+      end
+
+      def initialize(words, width = nil, height = nil)
+        @words = words
+        @width = width
+        @height = height
+      end
+
+      # Output JSON flattened word coordinates
+      #
+      # @return [String] JSON serialization of flattened word coordinates
+      def to_json
+        coordinates = {}
+        @words.each do |w|
+          word_chars = w[:word]
+          word_coords = w[:coordinates]
+          if coordinates[word_chars]
+            coordinates[word_chars] << word_coords
+          else
+            coordinates[word_chars] = [word_coords]
+          end
+        end
+        payload = { width: @width, height: @height, coords: coordinates }
+        JSON.generate(payload)
+      end
+    end
+  end
+end

data/lib/iiif_print/text_extraction.rb

@@ -0,0 +1,11 @@
+require 'iiif_print/text_extraction/alto_reader'
+require 'iiif_print/text_extraction/hocr_reader'
+require 'iiif_print/text_extraction/page_ocr'
+require 'iiif_print/text_extraction/render_alto'
+require 'iiif_print/text_extraction/word_coords_builder'
+
+module IiifPrint
+  # Module for text extraction (OCR or otherwise)
+  module TextExtraction
+  end
+end

data/lib/iiif_print/text_extraction_derivative_service.rb

@@ -0,0 +1,47 @@
+require 'iiif_print/text_formats_from_alto_service'
+
+module IiifPrint
+  class TextExtractionDerivativeService < BaseDerivativeService
+    # @param [Hash<Symbol,Symbol>]
+    #
+    # The key for the hash represents the file extension.  The key's value represents the instance
+    # method to call on {IiifPrint::TextExtraction::PageOCR}
+    class_attribute :ocr_derivatives, default: { txt: :plain, xml: :alto, json: :word_json }
+    class_attribute :alto_derivative_service_class, default: IiifPrint::TextFormatsFromALTOService
+    class_attribute :page_ocr_service_class, default: IiifPrint::TextExtraction::PageOCR
+    def initialize(file_set)
+      super(file_set)
+    end
+
+    def create_derivatives(src)
+      from_alto = alto_derivative_service_class.new(
+        file_set
+      )
+      return from_alto.create_derivatives(src) unless from_alto.alto_path.nil?
+      create_derivatives_from_ocr(src)
+    end
+
+    def create_derivatives_from_ocr(filename)
+      # TODO: Do we need this source_path instance variable?
+      @source_path = filename
+      ocr = page_ocr_service_class.new(filename)
+
+      ocr_derivatives.each do |extension, method_name|
+        path = prepare_path(extension.to_s)
+        write(content: ocr.public_send(method_name), path: path)
+      end
+    end
+
+    def write(content:, path:)
+      File.open(path, 'w') do |outfile|
+        outfile.write(content)
+      end
+    end
+
+    def cleanup_derivatives(*)
+      ocr_derivatives.keys do |extension|
+        super(extension.to_s)
+      end
+    end
+  end
+end

data/lib/iiif_print/text_formats_from_alto_service.rb

@@ -0,0 +1,77 @@
+module IiifPrint
+  # Plugin to make text format derviatives (JSON, plain-text) from ALTO,
+  #   either existing derivative, or an impending attachment.
+  #   NOTE: to keep this from conflicting with TextExtractionDerivativeService,
+  #         this class should be invoked by it, not PluggableDerivativeService.
+  class TextFormatsFromALTOService < BaseDerivativeService
+    self.target_extension = 'tiff'.freeze
+
+    def save_derivative(destination, data)
+      # Load/prepare base of "pairtree" dir structure for extension, fileset
+      prepare_path(destination)
+      #
+      save_path = derivative_path_factory.derivative_path_for_reference(
+        @file_set,
+        destination
+      )
+      # Write data as UTF-8 encoded text
+      File.open(save_path, "w:UTF-8") do |f|
+        f.write(data)
+      end
+    end
+
+    def nonempty_file?(path)
+      return false if path.nil?
+      return false unless File.exist?(path)
+      !File.size(path).zero?
+    end
+
+    # if there was no derivative yet, there might be one in-transit from
+    #   an ingest, so check for that, and use its source if applicable:
+    def incoming_alto_path
+      path = IiifPrint::DerivativeAttachment.where(
+        fileset_id: @file_set.id,
+        destination_name: 'xml'
+      ).pluck(:path).uniq.first
+      path if nonempty_file?(path)
+    end
+
+    def alto_path
+      # check first for existing, non-empty derivative data:
+      path = derivative_path_factory.derivative_path_for_reference(
+        @file_set,
+        'xml'
+      )
+      return path if nonempty_file?(path)
+      incoming_alto_path
+    end
+
+    def alto
+      path = alto_path
+      File.read(path, encoding: 'UTF-8') unless path.nil?
+    end
+
+    def create_derivatives(_filename)
+      # as this plugin makes derivatives of derivative, _filename is ignored
+      source_file = alto
+      return if source_file.nil?
+      # Image width from characterized primary file helps ensure proper scaling:
+      file = @file_set.original_file
+      width = file.nil? ? nil : file.width[0].to_i
+      height = file.nil? ? nil : file.height[0].to_i
+      # ALTOReader is responsible for transcoding, this class just saves result
+      reader = IiifPrint::TextExtraction::AltoReader.new(
+        source_file,
+        width,
+        height
+      )
+      save_derivative('json', reader.json)
+      save_derivative('txt', reader.text)
+    end
+
+    def cleanup_derivatives(*args)
+      # do nothing here; IiifPrint::TextExtractionDerivativeService
+      # has this job instead for cleaning ALTO, JSON, TXT.
+    end
+  end
+end

data/lib/iiif_print/tiff_derivative_service.rb

@@ -0,0 +1,50 @@
+require 'open3'
+
+module IiifPrint
+  class TIFFDerivativeService < BaseDerivativeService
+    self.target_extension = 'tiff'.freeze
+
+    # For imagemagick commands, the output type is determined by the
+    #   output file's extension.
+    # TIFF (LZW, 8 bit grayscale)
+    GRAY_CMD = 'convert %<source_file>s ' \
+               '-depth 8 -colorspace Gray ' \
+               '-compress lzw %<out_file>s'.freeze
+
+    # Monochrome one-bit black/white TIFF, Group 4 compressed:
+    MONO_CMD = 'convert %<source_file>s ' \
+               '-depth 1 -monochrome -compress Group4 -type bilevel ' \
+               '%<out_file>s'.freeze
+
+    # sRBG color TIFF (8 bits per channel, lzw)
+    COLOR_CMD = 'convert %<source_file>s ' \
+                '-depth 24 ' \
+                '-compress lzw %<out_file>s'.freeze
+
+    def initialize(file_set)
+      super(file_set)
+    end
+
+    # Get conversion command; command varies on whether or not we have
+    #   JP2 source, and whether we have color or grayscale material.
+    def convert_cmd
+      source_path = @source_path
+      source_path += '[0]' if @source_path.ends_with?('pdf')
+      template = use_color? ? COLOR_CMD : GRAY_CMD
+      template = MONO_CMD if one_bit?
+      format(template, source_file: source_path, out_file: @dest_path)
+    end
+
+    def create_derivatives(filename)
+      # Base class takes care of loading @source_path, @dest_path
+      super(filename)
+
+      # no creation of TIFF deriviative if primary is TIFF
+      return if mime_type == 'image/tiff'
+
+      return jp2_convert if mime_type == 'image/jp2'
+      # Otherwise, get, run imagemagick command to convert
+      im_convert
+    end
+  end
+end

data/lib/iiif_print/version.rb

@@ -0,0 +1,3 @@
+module IiifPrint
+  VERSION = '1.0.0'.freeze
+end

data/lib/iiif_print/works_controller_behavior.rb

@@ -0,0 +1,9 @@
+module IiifPrint
+  module WorksControllerBehaviorDecorator
+    # Extending the presenter to the base url which includes the protocol.
+    # We need the base url to render the facet links.
+    def iiif_manifest_presenter
+      super.tap { |i| i.base_url = request.base_url }
+    end
+  end
+end