mindee 3.14.0 → 3.16.0

data/lib/mindee/image/image_utils.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Mindee
+  # Image processing module.
+  module Image
+    # Miscellaneous image operations.
+    module ImageUtils
+      # Resizes a provided MiniMagick Image with the given width & height, if present.
+      # @param image [MiniMagick::Image] MiniMagick image handle.
+      # @param width [Integer] Width to comply with.
+      # @param height [Integer] Height to comply with.
+      def self.resize_image(image, width, height)
+        if width && height
+          image.resize "#{width}x#{height}"
+        elsif width
+          image.resize width.to_s
+        elsif height
+          image.resize "x#{height}"
+        end
+      end
+
+      # Compresses the quality of the provided MiniMagick image.
+      # @param image [MiniMagick::Image] MiniMagick image handle.
+      # @param quality [Integer] Quality to apply to the image. This is independent of a JPG's base quality.
+      def self.compress_image_quality(image, quality)
+        image.quality quality.to_s
+      end
+
+      # Mostly here so that IDEs don't get confused on the type (@type annotation fails sometimes.)
+      # @param [MiniMagick::Image, StringIO, File, Tempfile] image The input image
+      # @return [MiniMagick::Image]
+      def self.to_image(image)
+        if image.respond_to?(:read) && image.respond_to?(:rewind)
+          image.rewind
+          MiniMagick::Image.read(image)
+        elsif image.is_a?(MiniMagick::Image)
+          image
+        else
+          raise "Expected an I/O object or a MiniMagick::Image. '#{image.class}' given instead."
+        end
+      end
+
+      # Converts a StringIO containing an image into a MiniMagick image.
+      # @param image [MiniMagick::Image] the input image.
+      # @param format [String] Format parameter, left open for the future, but should be JPEG for current use-cases.
+      # @return [StringIO]
+      def self.image_to_stringio(image, format = 'JPEG')
+        image.format format
+        blob = image.to_blob
+        stringio = StringIO.new(blob)
+        stringio.rewind
+
+        stringio
+      end
+
+      # Computes the new dimensions for a given SKBitmap, and returns a scaled down version of it relative to the
+      # provided bounds.
+      # @param [MiniMagick::Image] original Input MiniMagick image.
+      # @param max_width [Integer] Maximum width. If not specified, the horizontal ratio will remain the same.
+      # @param max_height [Integer] Maximum height. If not specified, the vertical ratio will remain the same.
+      def self.calculate_new_dimensions(original, max_width: nil, max_height: nil)
+        raise 'Provided image could not be processed for resizing.' if original.nil?
+
+        return [original.width, original.height] if max_width.nil? && max_height.nil?
+
+        width_ratio = max_width ? max_width.to_f / original.width : Float::INFINITY
+        height_ratio = max_height ? max_height.to_f / original.height : Float::INFINITY
+
+        scale_factor = [width_ratio, height_ratio].min
+
+        new_width = (original.width * scale_factor).to_i
+        new_height = (original.height * scale_factor).to_i
+
+        [new_width, new_height]
+      end
+
+      # Computes the Height & Width from a page's media box. Falls back to the size of the initial image.
+      # @param image [MiniMagick::Image] The initial image that will fit into the page.
+      # @param media_box [Array<Integer>, nil]
+      # @return [Array<Integer>]
+      def self.calculate_dimensions_from_media_box(image, media_box)
+        if !media_box.nil? && media_box.any?
+          [
+            media_box[2]&.to_i || image[:width].to_i,
+            media_box[3]&.to_i || image[:height].to_i,
+          ]
+        else
+          [image[:width].to_i, image[:height].to_i]
+        end
+      end
+
+      # Transforms a PDF into a MagickImage. This is currently used for single-page PDFs.
+      # @param pdf_stream [StringIO] Input stream.
+      # @param image_quality [Integer] Quality to apply to the image.
+      # @return [MiniMagick::Image]
+      def self.pdf_to_magick_image(pdf_stream, image_quality)
+        compressed_image = MiniMagick::Image.read(pdf_stream.read)
+        compressed_image.format('jpg')
+        compressed_image.quality image_quality.to_s
+        compressed_image
+      end
+    end
+  end
+end

data/lib/mindee/image.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'image/image_compressor'
+require_relative 'image/image_utils'

data/lib/mindee/input/sources.rb

@@ -4,6 +4,7 @@ require 'stringio'
 require 'marcel'
 
 require_relative '../pdf'
+require_relative '../image'
 
 module Mindee
   module Input
@@ -126,6 +127,41 @@ module Mindee
           pdf_processor = Mindee::PDF::PdfProcessor.open_pdf(@io_stream)
           pdf_processor.pages.size
         end
+
+        # Compresses the file, according to the provided info.
+        # @param [Integer] quality Quality of the output file.
+        # @param [Integer, nil] max_width Maximum width (Ignored for PDFs).
+        # @param [Integer, nil] max_height Maximum height (Ignored for PDFs).
+        # @param [Boolean] force_source_text Whether to force the operation on PDFs with source text.
+        #   This will attempt to re-render PDF text over the rasterized original. If disabled, ignored the operation.
+        #   WARNING: this operation is strongly discouraged.
+        # @param [Boolean] disable_source_text If the PDF has source text, whether to re-apply it to the original or
+        #   not. Needs force_source_text to work.
+        def compress!(quality: 85, max_width: nil, max_height: nil, force_source_text: false, disable_source_text: true)
+          buffer = if pdf?
+                     Mindee::PDF::PDFCompressor.compress_pdf(
+                       @io_stream,
+                       quality: quality,
+                       force_source_text_compression: force_source_text,
+                       disable_source_text: disable_source_text
+                     )
+                   else
+                     Mindee::Image::ImageCompressor.compress_image(
+                       @io_stream,
+                       quality: quality,
+                       max_width: max_width,
+                       max_height: max_height
+                     )
+                   end
+          @io_stream = buffer
+          @io_stream.rewind
+        end
+
+        # Checks whether the file has source text if it is a pdf. False otherwise
+        # @return [Boolean] True if the file is a PDF and has source text.
+        def source_text?
+          Mindee::PDF::PDFTools.source_text?(@io_stream)
+        end
       end
 
       # Load a document from a path.

data/lib/mindee/parsing/standard/position_field.rb

@@ -31,6 +31,8 @@ module Mindee
 
         # rubocop:disable Metrics/CyclomaticComplexity
         # rubocop:disable Metrics/PerceivedComplexity
+
+        # String representation.
         # @return [String]
         def to_s
           return "Polygon with #{@polygon.size} points." if @polygon&.size&.positive?
@@ -40,6 +42,7 @@ module Mindee
 
           ''
         end
+
         # rubocop:enable Metrics/CyclomaticComplexity
         # rubocop:enable Metrics/PerceivedComplexity
 

data/lib/mindee/pdf/pdf_compressor.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'pdf-reader'
+PDFReader = PDF
+
+module Mindee
+  module PDF
+    # Image compressor module to handle PDF compression.
+    module PDFCompressor
+      # Compresses each page of a provided PDF stream. Skips if force_source_text isn't set and source text is detected.
+      # @param quality [Integer] Compression quality (70-100 for most JPG images in the test dataset).
+      # @param force_source_text_compression [Boolean] If true, attempts to re-write detected text.
+      # @param disable_source_text [Boolean] If true, doesn't re-apply source text to the original PDF.
+      def self.compress_pdf(pdf_data, quality: 85, force_source_text_compression: false, disable_source_text: true)
+        if PDFTools.source_text?(pdf_data)
+          if force_source_text_compression
+            if disable_source_text
+              puts "\e[33m[WARNING] Re-writing PDF source-text is an EXPERIMENTAL feature.\e[0m"
+            else
+              puts "\e[33m[WARNING] Source-file contains text, but disable_source_text flag is ignored. " \
+                   "Resulting file will not contain any embedded text.\e[0m"
+            end
+          else
+            puts "\e[33m[WARNING] Source-text detected in input PDF. Aborting operation.\e[0m"
+            return pdf_data
+          end
+        end
+
+        pdf_data.rewind
+        pdf = Origami::PDF.read(pdf_data)
+        pages = process_pdf_pages(pdf, quality)
+
+        output_pdf = create_output_pdf(pages, disable_source_text, pdf_data)
+
+        output_stream = StringIO.new
+        output_pdf.save(output_stream)
+        output_stream
+      end
+
+      # Processes all pages in the PDF.
+      # @param pdf [Origami::PDF] The Origami PDF object to process.
+      # @param quality [Integer] Compression quality.
+      # @return [Array<Origami::Page>] Processed pages.
+      def self.process_pdf_pages(pdf, quality)
+        pdf.pages.map.with_index do |page, index|
+          process_pdf_page(Mindee::PDF::PdfProcessor.get_page(pdf, index), index, quality, page[:MediaBox])
+        end
+      end
+
+      # Creates the output PDF with processed pages.
+      # @param pages [Array] Processed pages.
+      # @param disable_source_text [Boolean] Whether to disable source text.
+      # @param pdf_data [StringIO] Original PDF data.
+      # @return [Origami::PDF] Output PDF object.
+      def self.create_output_pdf(pages, disable_source_text, pdf_data)
+        output_pdf = Origami::PDF.new
+        # NOTE: Page order and XObject handling require adjustment due to origami adding the last page first.
+        pages.rotate!(1) if pages.count >= 2
+
+        inject_text(pdf_data, pages) unless disable_source_text
+
+        pages.each { |page| output_pdf.append_page(page) }
+
+        output_pdf
+      end
+
+      # Extracts text from a source text PDF, and injects it into a newly-created one.
+      # @param pdf_data [StringIO] Stream representation of the PDF.
+      # @param pages [Array<Origami::Page>] Array of pages containing the rasterized version of the initial pages.
+      def self.inject_text(pdf_data, pages)
+        reader = PDFReader::Reader.new(pdf_data)
+
+        reader.pages.each_with_index do |original_page, index|
+          break if index >= pages.length
+
+          receiver = PDFReader::Reader::PageTextReceiver.new
+          original_page.walk(receiver)
+
+          receiver.runs.each do |text_run|
+            x = text_run.origin.x
+            y = text_run.origin.y
+            text = text_run.text
+            font_size = text_run.font_size
+
+            content_stream = Origami::Stream.new
+            content_stream.dictionary[:Filter] = :FlateDecode
+            content_stream.data = "BT\n/F1 #{font_size} Tf\n#{x} #{y} Td\n(#{text}) Tj\nET\n"
+
+            pages[index].Contents.data += content_stream.data
+          end
+        end
+      end
+
+      # Takes in a page stream, rasterizes it into a JPEG image, and applies the result onto a new Origami PDF page.
+      # @param page_stream [StringIO] Stream representation of a single page from the initial PDF.
+      # @param page_index [Integer] Index of the current page. Technically not needed, but left for debugging purposes.
+      # @param image_quality [Integer] Quality to apply to the rasterized page.
+      # @param media_box [Array<Integer>, nil] Extracted media box from the page. Can be nil.
+      # @return [Origami::Page]
+      def self.process_pdf_page(page_stream, page_index, image_quality, media_box)
+        new_page = Origami::Page.new
+        compressed_image = Mindee::Image::ImageUtils.pdf_to_magick_image(page_stream, image_quality)
+        width, height = Mindee::Image::ImageUtils.calculate_dimensions_from_media_box(compressed_image, media_box)
+
+        compressed_xobject = PDF::PDFTools.create_xobject(compressed_image)
+        PDF::PDFTools.set_xobject_properties(compressed_xobject, compressed_image)
+
+        xobject_name = "X#{page_index + 1}"
+        PDF::PDFTools.add_content_to_page(new_page, xobject_name, width, height)
+        new_page.add_xobject(compressed_xobject, xobject_name)
+
+        PDF::PDFTools.set_page_dimensions(new_page, width, height)
+        new_page
+      end
+    end
+  end
+end

data/lib/mindee/pdf/{pdf_processing.rb → pdf_processor.rb}

@@ -18,6 +18,7 @@ module Mindee
 
       # @param io_stream [StreamIO]
       # @param options [Hash]
+      # @return [StringIO]
       def self.parse(io_stream, options)
         options = DEFAULT_OPTIONS.merge(options)
 
@@ -74,6 +75,22 @@ module Mindee
         io_stream.seek(0)
         pdf_parser.parse(io_stream)
       end
+
+      # Retrieves a PDF document's page.
+      #
+      # @param [Origami::PDF] pdf_doc Origami PDF handle.
+      # @param [Integer] page_id Page ID.
+      # @return [StringIO]
+      def self.get_page(pdf_doc, page_id)
+        stream = StringIO.new
+        pdf_doc.save(stream)
+
+        options = {
+          page_indexes: [page_id - 1],
+        }
+
+        parse(stream, options)
+      end
     end
   end
 end

data/lib/mindee/pdf/pdf_tools.rb

@@ -29,6 +29,106 @@ module Mindee
         io_stream.set_encoding Encoding::BINARY
         io_stream
       end
+
+      # Checks a PDFs stream content for text operators
+      # See https://opensource.adobe.com/dc-acrobat-sdk-docs/pdfstandards/PDF32000_2008.pdf page 243-251.
+      # @param [StringIO] stream Stream object from a PDFs page.
+      # @return [Boolean] True if a text operator is found in the stream.
+      def self.stream_has_text?(stream)
+        data = stream.data
+        return false if data.nil? || data.empty?
+
+        text_operators = ['Tc', 'Tw', 'Th', 'TL', 'Tf', 'Tk', 'Tr', 'Tm', 'T*', 'Tj', 'TJ', "'", '"']
+        text_operators.any? { |op| data.include?(op) }
+      end
+
+      # Checks whether the file has source_text. Sends false if the file isn't a PDF.
+      # @param [StringIO] pdf_data
+      # @return [Boolean] True if the pdf has source text, false otherwise.
+      def self.source_text?(pdf_data)
+        begin
+          pdf_data.rewind
+          pdf = Origami::PDF.read(pdf_data)
+
+          pdf.each_page do |page|
+            next unless page[:Contents]
+
+            contents = page[:Contents].solve
+            contents = [contents] unless contents.is_a?(Origami::Array)
+
+            contents.each do |stream_ref|
+              stream = stream_ref.solve
+              return true if stream_has_text?(stream)
+            end
+          end
+
+          false
+        end
+
+        false
+      rescue Origami::InvalidPDFError
+        false
+      end
+
+      def self.create_xobject(image)
+        image_io = Mindee::Image::ImageUtils.image_to_stringio(image)
+        Origami::Graphics::ImageXObject.from_image_file(image_io, 'jpg')
+      end
+
+      def self.set_xobject_properties(xobject, image)
+        xobject.dictionary[:BitsPerComponent] = 8
+        xobject.dictionary[:Filter] = determine_filter(image)
+        xobject.dictionary[:Width] = image[:width]
+        xobject.dictionary[:Height] = image[:height]
+        xobject.dictionary[:ColorSpace] = determine_colorspace(image)
+      end
+
+      def self.determine_filter(image)
+        filter = image.data['properties']['filter']
+        case filter
+        when %r{Zip}i then :FlateDecode
+        when %r{LZW}i then :LZWDecode
+        else :DCTDecode
+        end
+      end
+
+      def self.determine_colorspace(image)
+        colorspace = image.data['colorspace']
+        case colorspace
+        when 'CMYK' then :DeviceCMYK
+        when 'Gray', 'PseudoClass Gray' then :DeviceGray
+        else :DeviceRGB
+        end
+      end
+
+      def self.add_content_to_page(page, xobject_name, width, height)
+        content = "q\n#{width} 0 0 #{height} 0 0 cm\n/#{xobject_name} Do\nQ\n"
+        content_stream = Origami::Stream.new(content)
+        page.Contents = content_stream
+      end
+
+      def self.set_page_dimensions(page, width, height)
+        page[:MediaBox] = [0, 0, width, height]
+        page[:CropBox] = [0, 0, width, height]
+      end
+
+      def self.process_image_xobject(image_data, image_quality, width, height)
+        compressed_data = Image::ImageCompressor.compress_image(
+          image_data,
+          quality: image_quality,
+          max_width: width,
+          max_height: height
+        )
+
+        new_image = Origami::Graphics::ImageXObject.new
+        new_image.data = compressed_data
+        new_image.Width = width
+        new_image.Height = height
+        new_image.ColorSpace = :DeviceRGB
+        new_image.BitsPerComponent = 8
+
+        new_image
+      end
     end
   end
 end

data/lib/mindee/pdf.rb

@@ -1,3 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'pdf/pdf_processing'
+require_relative 'pdf/pdf_compressor'
+require_relative 'pdf/pdf_processor'
+require_relative 'pdf/pdf_tools'

data/lib/mindee/product/business_card/business_card_v1.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'business_card_v1_document'
+require_relative 'business_card_v1_page'
+
+module Mindee
+  module Product
+    # Business Card module.
+    module BusinessCard
+      # Business Card API version 1 inference prediction.
+      class BusinessCardV1 < Mindee::Parsing::Common::Inference
+        @endpoint_name = 'business_card'
+        @endpoint_version = '1'
+
+        # @param prediction [Hash]
+        def initialize(prediction)
+          super
+          @prediction = BusinessCardV1Document.new(prediction['prediction'], nil)
+          @pages = []
+          prediction['pages'].each do |page|
+            if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
+              @pages.push(BusinessCardV1Page.new(page))
+            end
+          end
+        end
+
+        class << self
+          # Name of the endpoint for this product.
+          # @return [String]
+          attr_reader :endpoint_name
+          # Version for this product.
+          # @return [String]
+          attr_reader :endpoint_version
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/business_card/business_card_v1_document.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+
+module Mindee
+  module Product
+    module BusinessCard
+      # Business Card API version 1.0 document data.
+      class BusinessCardV1Document < Mindee::Parsing::Common::Prediction
+        include Mindee::Parsing::Standard
+        # The address of the person.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :address
+        # The company the person works for.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :company
+        # The email address of the person.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :email
+        # The Fax number of the person.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :fax_number
+        # The given name of the person.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :firstname
+        # The job title of the person.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :job_title
+        # The lastname of the person.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :lastname
+        # The mobile number of the person.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :mobile_number
+        # The phone number of the person.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :phone_number
+        # The social media profiles of the person or company.
+        # @return [Array<Mindee::Parsing::Standard::StringField>]
+        attr_reader :social_media
+        # The website of the person or company.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :website
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          super()
+          @address = StringField.new(prediction['address'], page_id)
+          @company = StringField.new(prediction['company'], page_id)
+          @email = StringField.new(prediction['email'], page_id)
+          @fax_number = StringField.new(prediction['fax_number'], page_id)
+          @firstname = StringField.new(prediction['firstname'], page_id)
+          @job_title = StringField.new(prediction['job_title'], page_id)
+          @lastname = StringField.new(prediction['lastname'], page_id)
+          @mobile_number = StringField.new(prediction['mobile_number'], page_id)
+          @phone_number = StringField.new(prediction['phone_number'], page_id)
+          @social_media = []
+          prediction['social_media'].each do |item|
+            @social_media.push(StringField.new(item, page_id))
+          end
+          @website = StringField.new(prediction['website'], page_id)
+        end
+
+        # @return [String]
+        def to_s
+          social_media = @social_media.join("\n #{' ' * 14}")
+          out_str = String.new
+          out_str << "\n:Firstname: #{@firstname}".rstrip
+          out_str << "\n:Lastname: #{@lastname}".rstrip
+          out_str << "\n:Job Title: #{@job_title}".rstrip
+          out_str << "\n:Company: #{@company}".rstrip
+          out_str << "\n:Email: #{@email}".rstrip
+          out_str << "\n:Phone Number: #{@phone_number}".rstrip
+          out_str << "\n:Mobile Number: #{@mobile_number}".rstrip
+          out_str << "\n:Fax Number: #{@fax_number}".rstrip
+          out_str << "\n:Address: #{@address}".rstrip
+          out_str << "\n:Website: #{@website}".rstrip
+          out_str << "\n:Social Media: #{social_media}".rstrip
+          out_str[1..].to_s
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/business_card/business_card_v1_page.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'business_card_v1_document'
+
+module Mindee
+  module Product
+    module BusinessCard
+      # Business Card API version 1.0 page data.
+      class BusinessCardV1Page < Mindee::Parsing::Common::Page
+        # @param prediction [Hash]
+        def initialize(prediction)
+          super(prediction)
+          @prediction = BusinessCardV1PagePrediction.new(
+            prediction['prediction'],
+            prediction['id']
+          )
+        end
+      end
+
+      # Business Card V1 page prediction.
+      class BusinessCardV1PagePrediction < BusinessCardV1Document
+        # @return [String]
+        def to_s
+          out_str = String.new
+          out_str << "\n#{super}"
+          out_str
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/delivery_note/delivery_note_v1.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'delivery_note_v1_document'
+require_relative 'delivery_note_v1_page'
+
+module Mindee
+  module Product
+    # Delivery note module.
+    module DeliveryNote
+      # Delivery note API version 1 inference prediction.
+      class DeliveryNoteV1 < Mindee::Parsing::Common::Inference
+        @endpoint_name = 'delivery_notes'
+        @endpoint_version = '1'
+
+        # @param prediction [Hash]
+        def initialize(prediction)
+          super
+          @prediction = DeliveryNoteV1Document.new(prediction['prediction'], nil)
+          @pages = []
+          prediction['pages'].each do |page|
+            if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
+              @pages.push(DeliveryNoteV1Page.new(page))
+            end
+          end
+        end
+
+        class << self
+          # Name of the endpoint for this product.
+          # @return [String]
+          attr_reader :endpoint_name
+          # Version for this product.
+          # @return [String]
+          attr_reader :endpoint_version
+        end
+      end
+    end
+  end
+end