mindee 2.2.0 → 3.0.0

data/lib/mindee/parsing/common/inference.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'product'
+
+module Mindee
+  module Parsing
+    # Common fields used for most documents.
+    module Common
+      # Abstract class for prediction Inferences
+      # Holds prediction for a page or entire document.
+      class Inference
+        # @return [Boolean]
+        attr_reader :is_rotation_applied
+        # @return [Array<Mindee::Parsing::Common::Page>]
+        attr_reader :pages
+        # @return [Mindee::Parsing::Common::Prediction]
+        attr_reader :prediction
+        # @return [Mindee::Parsing::Common::Product]
+        attr_reader :product
+
+        # @param raw_prediction [Hash]
+        def initialize(raw_prediction)
+          @is_rotation_applied = raw_prediction['is_rotation_applied']
+          @product = Product.new(raw_prediction['product'])
+          @pages = []
+        end
+
+        # @return [String]
+        def to_s
+          is_rotation_applied = @is_rotation_applied ? 'Yes' : 'No'
+          out_str = String.new
+          out_str << "Inference\n#########"
+          out_str << "\n:Product: #{@product.name} v#{@product.version}"
+          out_str << "\n:Rotation applied: #{is_rotation_applied}"
+          out_str << "\n\nPrediction\n=========="
+          out_str << "\n#{@prediction}"
+          out_str << "\n\nPage Predictions\n================\n\n"
+          out_str << @pages.map(&:to_s).join("\n\n")
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/common/ocr/mvision_v1.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Parsing
+    module Common
+      module Ocr
+        # Mindee Vision V1.
+        class MVisionV1
+          # List of pages.
+          # @return [Array<OcrPage>]
+          attr_reader :pages
+
+          # @param prediction [Hash]
+          def initialize(prediction)
+            @pages = []
+            prediction['pages'].each do |page_prediction|
+              @pages.push(OcrPage.new(page_prediction))
+            end
+          end
+
+          # @return [String]
+          def to_s
+            out_str = String.new
+            @pages.map do |page|
+              out_str << "\n"
+              out_str << page.to_s
+            end
+            out_str.strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/common/ocr/ocr.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative 'mvision_v1'
+
+module Mindee
+  module Parsing
+    module Common
+      module Ocr
+        # A single word.
+        class OcrWord
+          # The confidence score, value will be between 0.0 and 1.0
+          # @return [Float]
+          attr_accessor :confidence
+          # @return [String]
+          attr_reader :text
+          # @return [Mindee::Geometry::Quadrilateral]
+          attr_reader :bounding_box
+          # @return [Mindee::Geometry::Polygon]
+          attr_reader :polygon
+
+          # @param prediction [Hash]
+          def initialize(prediction)
+            @text = prediction['text']
+            @confidence = prediction['confidence']
+            @polygon = Geometry.polygon_from_prediction(prediction['polygon'])
+            @bounding_box = Geometry.get_bounding_box(@polygon) unless @polygon.nil? || @polygon.empty?
+          end
+
+          # @return [String]
+          def to_s
+            @text.to_s
+          end
+        end
+
+        # A list of words which are on the same line.
+        class OcrLine < Array
+          # @param prediction [Hash, nil]
+          # @param from_array [Array, nil]
+          def initialize(prediction = nil, from_array = nil)
+            if !prediction.nil?
+              super(prediction.map { |word_prediction| OcrWord.new(word_prediction) })
+            elsif !from_array.nil?
+              super(from_array)
+            end
+          end
+
+          # Sort the words on the line from left to right.
+          # @return [OcrLine]
+          def sort_on_x
+            from_array = sort do |word1, word2|
+              Geometry.get_min_max_x(word1.polygon).min <=> Geometry.get_min_max_x(word2.polygon).min
+            end
+            OcrLine.new(nil, from_array)
+          end
+
+          # @return [String]
+          def to_s
+            each(&:to_s).join(' ')
+          end
+        end
+
+        # OCR extraction for a single page.
+        class OcrPage
+          # All the words on the page, in semi-random order.
+          # @return [Array<OcrWord>]
+          attr_reader :all_words
+          # @return [Array<OcrLine>]
+          attr_reader :lines
+
+          # @param prediction [Hash]
+          def initialize(prediction)
+            @lines = []
+            @all_words = []
+            prediction['all_words'].each do |word_prediction|
+              @all_words.push(OcrWord.new(word_prediction))
+            end
+          end
+
+          # All the words on the page, ordered in lines.
+          # @return [Array<OcrLine>]
+          def all_lines
+            @lines = to_lines if @lines.empty?
+            @lines
+          end
+
+          # @return [String]
+          def to_s
+            lines = all_lines
+            return '' if lines.empty?
+
+            out_str = String.new
+            lines.map do |line|
+              out_str << "#{line}\n" unless line.to_s.strip.empty?
+            end
+            out_str.strip
+          end
+
+          private
+
+          # Helper function that iterates through all the words and compares them to a candidate
+          # @param sorted_words [Array<OcrWord>]
+          # @param current [OcrWord]
+          # @param indexes [Array<Integer>]
+          # @param lines [Array<OcrLine>]
+          def parse_one(sorted_words, current, indexes, lines)
+            line = OcrLine.new([])
+            sorted_words.each_with_index do |word, idx|
+              next if indexes.include?(idx)
+
+              if current.nil?
+                current = word
+                indexes.push(idx)
+                line = OcrLine.new([])
+                line.push(word)
+              elsif words_on_same_line?(current, word)
+                line.push(word)
+                indexes.push(idx)
+              end
+            end
+            lines.push(line.sort_on_x) if line.any?
+          end
+
+          # Order all the words on the page into lines.
+          # @return [Array<OcrLine>]
+          def to_lines
+            current = nil
+            indexes = []
+            lines = []
+
+            # make sure words are sorted from top to bottom
+            all_words = @all_words.sort_by { |word| Geometry.get_min_max_y(word.polygon).min }
+            all_words.each do
+              parse_one(all_words, current, indexes, lines)
+              current = nil
+            end
+            lines
+          end
+
+          # Determine if two words are on the same line.
+          # @param current_word [Mindee::Parsing::Common::Ocr::OcrWord]
+          # @param next_word [Mindee::Parsing::Common::Ocr::OcrWord]
+          # @return [Boolean]
+          def words_on_same_line?(current_word, next_word)
+            current_in_next = current_word.polygon.point_in_y?(next_word.polygon.centroid)
+            next_in_current = next_word.polygon.point_in_y?(current_word.polygon.centroid)
+            current_in_next || next_in_current
+          end
+        end
+
+        # OCR extraction from the entire document.
+        class Ocr
+          # Mindee Vision v1 results.
+          # @return [Mindee::Parsing::Common::Ocr::MVisionV1]
+          attr_reader :mvision_v1
+
+          # @param prediction [Hash]
+          def initialize(prediction)
+            @mvision_v1 = MVisionV1.new(prediction['mvision-v1'])
+          end
+
+          # @return [String]
+          def to_s
+            @mvision_v1.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/common/ocr.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'ocr/ocr'

data/lib/mindee/parsing/common/orientation.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Parsing
+    module Common
+      # Page orientation
+      class Orientation
+        # @return [Integer]
+        attr_reader :page_id
+        # A prediction among these 3 possible outputs:
+        #   * 0 degrees: the page is already upright
+        #   * 90 degrees: the page must be rotated clockwise to be upright
+        #   * 270 degrees: the page must be rotated counterclockwise to be upright
+        # @return [Integer, nil]
+        attr_reader :value
+
+        # @param prediction [Hash]
+        # @param page_id [Integer]
+        def initialize(prediction, page_id)
+          @value = prediction['value']
+          @page_id = page_id
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/common/page.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'product'
+
+module Mindee
+  module Parsing
+    # Common fields used for most documents.
+    module Common
+      # Abstract wrapper class for prediction Pages
+      # Holds prediction for a page as well as it's orientation and  id.
+      class Page
+        # Id of the page (as given by the API).
+        # @return [Integer]
+        attr_reader :page_id
+        # Orientation of the page.
+        # @return [Mindee::Parsing::Common::Orientation]
+        attr_reader :orientation
+        # Page prediction
+        # @return [Mindee::Parsing::Common::Prediction]
+        attr_reader :prediction
+
+        # @param raw_prediction [Hash]
+        def initialize(raw_prediction)
+          @page_id = raw_prediction['id']
+          @orientation = Orientation.new(raw_prediction['orientation'], @page_id)
+        end
+
+        # @return [String]
+        def to_s
+          out_str = String.new
+          title = "Page #{@page_id}"
+          out_str << "#{title}\n"
+          out_str << ('-' * title.size)
+          out_str << @prediction.to_s
+          out_str
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/common/prediction.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Parsing
+    module Common
+      # Abstract class for all predictions
+      class Prediction
+        # @return [String]
+        def to_s
+          ''
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/common/product.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Parsing
+    module Common
+      # Product information
+      class Product
+        attr_reader :name, :type, :version
+
+        # @param prediction [Hash]
+        def initialize(prediction)
+          @name = prediction['name']
+          @type = prediction['type']
+          @version = prediction['version']
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/common.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'common/api_response'
+require_relative 'common/document'
+require_relative 'common/error'
+require_relative 'common/inference'
+require_relative 'common/ocr'
+require_relative 'common/prediction'
+require_relative 'common/orientation'
+require_relative 'common/page'

data/lib/mindee/parsing/custom/classification_field.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Parsing
+    module Custom
+      # Document classification (custom docs)
+      class ClassificationField
+        # The classification value
+        # @return [String]
+        attr_reader :value
+        # The confidence score, value will be between 0.0 and 1.0
+        # @return [Float]
+        attr_accessor :confidence
+
+        # @param prediction [Hash]
+        def initialize(prediction)
+          @value = prediction['value']
+          @confidence = prediction['confidence']
+        end
+
+        # @return [String]
+        def to_s
+          @value.nil? ? '' : @value
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/custom/list_field.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Parsing
+    module Custom
+      # Field in a list.
+      class ListFieldItem
+        # The confidence score, value will be between 0.0 and 1.0
+        # @return [Float]
+        attr_accessor :confidence
+        # @return [Mindee::Geometry::Quadrilateral]
+        attr_reader :bounding_box
+        # @return [Mindee::Geometry::Polygon]
+        attr_reader :polygon
+        # @return [Array, Hash, String, nil]
+        attr_reader :content
+
+        # @param prediction [Hash]
+        def initialize(prediction)
+          @content = prediction['content']
+          @confidence = prediction['confidence']
+          @polygon = Geometry.polygon_from_prediction(prediction['polygon'])
+          @bounding_box = Geometry.get_bounding_box(@polygon) unless @polygon.nil? || @polygon.empty?
+        end
+
+        # @return [String]
+        def to_s
+          @content.to_s
+        end
+      end
+
+      # Field where actual values are kept in a list (custom docs).
+      class ListField
+        # @return [Array<Mindee::Parsing::Custom::ListFieldItem>]
+        attr_reader :values
+        # @return [Integer, nil]
+        attr_reader :page_id
+        # true if the field was reconstructed or computed using other fields.
+        # @return [Boolean]
+        attr_reader :reconstructed
+        # The confidence score, value will be between 0.0 and 1.0
+        # @return [Float]
+        attr_accessor :confidence
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        # @param reconstructed [Boolean]
+        def initialize(prediction, page_id, reconstructed: false)
+          @values = []
+          @confidence = prediction['confidence']
+          @page_id = page_id || prediction['page_id']
+          @reconstructed = reconstructed
+
+          prediction['values'].each do |field|
+            @values.push(ListFieldItem.new(field))
+          end
+        end
+
+        # @return [Array]
+        def contents_list
+          @values.map(&:content)
+        end
+
+        # @return [String]
+        def contents_str(separator: ' ')
+          @values.map(&:to_s).join(separator)
+        end
+
+        # @return [String]
+        def to_s
+          contents_str(separator: ' ')
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/custom.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'custom/classification_field'
+require_relative 'custom/list_field'

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'base_field'
+
+module Mindee
+  module Parsing
+    module Standard
+      # Represents tax information.
+      class AmountField < Field
+        # Amount value as 3 decimal float
+        # @return [Float, nil]
+        attr_reader :value
+
+        def initialize(prediction, page_id, reconstructed: false)
+          super
+          @value = @value.round(3) unless @value.nil?
+        end
+
+        # @return [String]
+        def to_s
+          Field.float_to_string(@value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative '../../geometry'
+
+module Mindee
+  module Parsing
+    module Standard
+      # Base Field object, upon which fields and feature fields are built
+      class AbstractField
+        # @return [Mindee::Geometry::Quadrilateral, nil]
+        attr_reader :bounding_box
+        # @return [Mindee::Geometry::Polygon, nil]
+        attr_reader :polygon
+        # @return [Integer, nil]
+        attr_reader :page_id
+        # The confidence score, value will be between 0.0 and 1.0
+        # @return [Float, nil]
+        attr_accessor :confidence
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          @confidence = prediction['confidence'] if prediction.key?('confidence')
+          @polygon = Geometry.polygon_from_prediction(prediction['polygon']) if prediction.key?('polygon')
+          @bounding_box = Geometry.get_bounding_box(@polygon) unless @polygon.nil? || @polygon.empty?
+          @page_id = page_id || prediction['page_id']
+        end
+
+        # @return [String]
+        def to_s
+          @value ? @value.to_s : ''
+        end
+
+        # Multiply all the Mindee::Parsing::Standard::Field confidences in the array.
+        # @return [Float]
+        def self.array_confidence(field_array)
+          product = 1
+          field_array.each do |field|
+            return 0.0 if field.confidence.nil?
+
+            product *= field.confidence
+          end
+          product.to_f
+        end
+
+        # Add all the Mindee::Parsing::Standard::Field values in the array.
+        # @return [Float]
+        def self.array_sum(field_array)
+          arr_sum = 0
+          field_array.each do |field|
+            return 0.0 if field.value.nil?
+
+            arr_sum += field.value
+          end
+          arr_sum.to_f
+        end
+
+        # @param value [Float]
+        # @param min_precision [Integer]
+        # @return [String]
+        def self.float_to_string(value, min_precision = 2)
+          return String.new if value.nil?
+
+          precision = value.to_f.to_s.split('.')[1].size
+          precision = [precision, min_precision].max
+          format_string = "%.#{precision}f"
+          format(format_string, value)
+        end
+      end
+
+      # Base field object.
+      class Field < AbstractField
+        # @return [String, Float, Integer, Boolean]
+        attr_reader :value
+        # true if the field was reconstructed or computed using other fields.
+        # @return [Boolean]
+        attr_reader :reconstructed
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        # @param reconstructed [Boolean]
+        def initialize(prediction, page_id, reconstructed: false)
+          super(prediction, page_id)
+          @value = prediction['value']
+          @reconstructed = reconstructed
+        end
+      end
+
+      # Feature field object wrapper for specialized methods.
+      class FeatureField < AbstractField
+        # Format strings for display by shortening long strings and assigning empty ones.
+        # @param in_str [String, nil]
+        # @param max_col_size [int, nil]
+        # @return [String]
+        def format_for_display(in_str, max_col_size = nil)
+          return '' if in_str.nil?
+          return in_str if max_col_size.nil?
+
+          in_str.length < max_col_size ? in_str : "#{in_str[0..max_col_size - 3]}..."
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'base_field'
+
+module Mindee
+  module Parsing
+    module Standard
+      # Represents a classifier value.
+      class ClassificationField < Field
+        # Value as String
+        # @return [String]
+        attr_reader :value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Parsing
+    module Standard
+      # Company registration number or code, and its type.
+      class CompanyRegistration < Field
+        # @return [String]
+        attr_reader :type
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        # @param reconstructed [Boolean]
+        def initialize(prediction, page_id, reconstructed: false)
+          super
+          @type = prediction['type']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'date'
+
+require_relative 'base_field'
+
+module Mindee
+  module Parsing
+    module Standard
+      # Represents a date.
+      class DateField < Field
+        # The date as a standard Ruby `Date` object.
+        # @return [Date, nil]
+        attr_reader :date_object
+        # The ISO 8601 representation of the date, regardless of the `raw` contents.
+        # @return [String, nil]
+        attr_reader :value
+        # The textual representation of the date as found on the document.
+        # @return [String, nil]
+        attr_reader :raw
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          super
+          return unless @value
+
+          @date_object = Date.parse(@value)
+          @raw = prediction['raw']
+        end
+      end
+    end
+  end
+end