mindee 3.13.0 → 3.15.0

data/lib/mindee/extraction/common/image_extractor.rb

@@ -9,180 +9,168 @@ require_relative 'extracted_image'
 
 module Mindee
   # Image Extraction Module.
-  module ImageExtraction
-    def self.attach_image_as_new_file(input_buffer)
-      # Attaches an image as a new page in a PdfDocument object.
-      #
-      # @param [StringIO] input_buffer Input buffer. Only supports JPEG.
-      # @return [Origami::PDF] A PdfDocument handle.
-
-      magick_image = MiniMagick::Image.read(input_buffer)
-      # NOTE: some jpeg images get rendered as three different versions of themselves per output if the format isn't
-      # converted.
-      magick_image.format('jpg')
-      original_density = magick_image.resolution
-      scale_factor = original_density[0].to_f / 4.166666 # No clue why bit the resolution needs to be reduced for
-      # the pdf otherwise the resulting image shrinks.
-      magick_image.format('pdf', 0, { density: scale_factor.to_s })
-      Origami::PDF.read(StringIO.new(magick_image.to_blob))
-    end
-
-    # Extracts multiple images from a given local input source.
-    #
-    # @param [Mindee::Input::Source::LocalInputSource] input_source
-    # @param [Integer] page_id ID of the Page to extract from.
-    # @param [Array<Array<Mindee::Geometry::Point>>, Array<Mindee::Geometry::Quadrangle>] polygons List of coordinates
-    # to extract.
-    # @return [Array<Mindee::ImageExtraction::ExtractedImage>] Extracted Images.
-    def extract_multiple_images_from_source(input_source, page_id, polygons)
-      new_stream = load_doc(input_source, page_id)
-      new_stream.seek(0)
-
-      extract_images_from_polygons(input_source, new_stream, page_id, polygons)
-    end
+  module Extraction
+    # Image Extraction wrapper class.
+    module ImageExtractor
+      def self.attach_image_as_new_file(input_buffer, format: 'jpg')
+        # Attaches an image as a new page in a PdfDocument object.
+        #
+        # @param [StringIO] input_buffer Input buffer. Only supports JPEG.
+        # @return [Origami::PDF] A PdfDocument handle.
+
+        magick_image = MiniMagick::Image.read(input_buffer)
+        # NOTE: some jpeg images get rendered as three different versions of themselves per output if the format isn't
+        # converted.
+        magick_image.format(format)
+        original_density = magick_image.resolution
+        scale_factor = original_density[0].to_f / 4.166666 # No clue why the resolution needs to be reduced for
+        # the pdf otherwise the resulting image shrinks.
+        magick_image.format('pdf', 0, { density: scale_factor.to_s })
+        Origami::PDF.read(StringIO.new(magick_image.to_blob))
+      end
 
-    # Retrieves a PDF document's page.
-    #
-    # @param [Origami::PDF] pdf_doc Origami PDF handle.
-    # @param [Integer] page_id Page ID.
-    def get_page(pdf_doc, page_id)
-      stream = StringIO.new
-      pdf_doc.save(stream)
+      # Extracts multiple images from a given local input source.
+      #
+      # @param [Mindee::Input::Source::LocalInputSource] input_source
+      # @param [Integer] page_id ID of the Page to extract from.
+      # @param [Array<Array<Mindee::Geometry::Point>>, Array<Mindee::Geometry::Quadrangle>] polygons List of coordinates
+      # to extract.
+      # @return [Array<Mindee::Extraction::ExtractedImage>] Extracted Images.
+      def self.extract_multiple_images_from_source(input_source, page_id, polygons)
+        new_stream = load_input_source_pdf_page_as_image(input_source, page_id)
+        new_stream.seek(0)
+
+        extract_images_from_polygons(input_source, new_stream, page_id, polygons)
+      end
 
-      options = {
-        page_indexes: [page_id - 1],
-      }
+      # Extracts images from their positions on a file (as polygons).
+      #
+      # @param [Mindee::Input::Source::LocalInputSource] input_source Local input source.
+      # @param [StringIO] pdf_stream Buffer of the PDF.
+      # @param [Integer] page_id Page ID.
+      # @param [Array<Mindee::Geometry::Point, Mindee::Geometry::Polygon, Mindee::Geometry::Quadrangle>] polygons
+      # @return [Array<Mindee::Extraction::ExtractedImage>] Extracted Images.
+      def self.extract_images_from_polygons(input_source, pdf_stream, page_id, polygons)
+        extracted_elements = []
+
+        polygons.each_with_index do |polygon, element_id|
+          polygon = normalize_polygon(polygon)
+          page_content = read_page_content(pdf_stream)
+
+          min_max_x = Geometry.get_min_max_x([
+                                               polygon.top_left,
+                                               polygon.bottom_right,
+                                               polygon.top_right,
+                                               polygon.bottom_left,
+                                             ])
+          min_max_y = Geometry.get_min_max_y([
+                                               polygon.top_left,
+                                               polygon.bottom_right,
+                                               polygon.top_right,
+                                               polygon.bottom_left,
+                                             ])
+          file_extension = determine_file_extension(input_source)
+          cropped_image = crop_image(page_content, min_max_x, min_max_y)
+          if file_extension == 'pdf'
+            cropped_image.format('jpg')
+          else
+            cropped_image.format(file_extension)
+          end
+
+          buffer = StringIO.new
+          write_image_to_buffer(cropped_image, buffer)
+          file_name = "#{input_source.filename}_page#{page_id}-#{element_id}.#{file_extension}"
+
+          extracted_elements << create_extracted_image(buffer, file_name, page_id, element_id)
+        end
 
-      Mindee::PDF::PdfProcessor.parse(stream, options)
-    end
+        extracted_elements
+      end
 
-    # Extracts images from their positions on a file (as polygons).
-    #
-    # @param [Mindee::Input::Source::LocalInputSource] input_source Local input source.
-    # @param [StringIO] pdf_stream Buffer of the PDF.
-    # @param [Integer] page_id Page ID.
-    # @param [Array<Mindee::Geometry::Point, Mindee::Geometry::Polygon, Mindee::Geometry::Quadrangle>] polygons
-    # @return [Array<Mindee::ImageExtraction::ExtractedImage>] Extracted Images.
-    def extract_images_from_polygons(input_source, pdf_stream, page_id, polygons)
-      extracted_elements = []
-
-      polygons.each_with_index do |polygon, element_id|
-        polygon = normalize_polygon(polygon)
-        page_content = read_page_content(pdf_stream)
-
-        min_max_x = Geometry.get_min_max_x([
-                                             polygon.top_left,
-                                             polygon.bottom_right,
-                                             polygon.top_right,
-                                             polygon.bottom_left,
-                                           ])
-        min_max_y = Geometry.get_min_max_y([
-                                             polygon.top_left,
-                                             polygon.bottom_right,
-                                             polygon.top_right,
-                                             polygon.bottom_left,
-                                           ])
-        file_extension = determine_file_extension(input_source)
-        cropped_image = crop_image(page_content, min_max_x, min_max_y)
-        if file_extension == 'pdf'
-          cropped_image.format('jpg')
+      # Retrieves the bounding box of a polygon.
+      #
+      # @param [Array<Point>, Mindee::Geometry::Polygon] polygon
+      def self.normalize_polygon(polygon)
+        if polygon.is_a?(Mindee::Geometry::Polygon)
+          Mindee::Geometry.get_bounding_box(polygon)
         else
-          cropped_image.format(file_extension)
+          polygon
         end
-
-        buffer = StringIO.new
-        write_image_to_buffer(cropped_image, buffer)
-        file_name = "#{input_source.filename}_page#{page_id}-#{element_id}.#{file_extension}"
-
-        extracted_elements << create_extracted_image(buffer, file_name, page_id, element_id)
       end
 
-      extracted_elements
-    end
-
-    # Retrieves the bounding box of a polygon.
-    #
-    # @param [Array<Point>, Mindee::Geometry::Polygon] polygon
-    def normalize_polygon(polygon)
-      if polygon.is_a?(Mindee::Geometry::Polygon)
-        Mindee::Geometry.get_bounding_box(polygon)
-      else
-        polygon
+      # Loads a buffer into a MiniMagick Image.
+      #
+      # @param [StringIO] pdf_stream Buffer containg the PDF
+      # @return [MiniMagick::Image] a valid MiniMagick image handle.
+      def self.read_page_content(pdf_stream)
+        pdf_stream.rewind
+        MiniMagick::Image.read(pdf_stream)
       end
-    end
 
-    # Loads a buffer into a MiniMagick Image.
-    #
-    # @param [StringIO] pdf_stream Buffer containg the PDF
-    # @return [MiniMagick::Image] a valid MiniMagick image handle.
-    def read_page_content(pdf_stream)
-      pdf_stream.rewind
-      MiniMagick::Image.read(pdf_stream)
-    end
-
-    # Crops a MiniMagick Image from a the given bounding box.
-    #
-    # @param [MiniMagick::Image] image Input Image.
-    # @param [Mindee::Geometry::MinMax] min_max_x minimum & maximum values for the x coordinates.
-    # @param [Mindee::Geometry::MinMax] min_max_y minimum & maximum values for the y coordinates.
-    def crop_image(image, min_max_x, min_max_y)
-      width = image[:width].to_i
-      height = image[:height].to_i
-
-      image.format('jpg')
-      new_width = (min_max_x.max - min_max_x.min) * width
-      new_height = (min_max_y.max - min_max_y.min) * height
-      image.crop("#{new_width}x#{new_height}+#{min_max_x.min * width}+#{min_max_y.min * height}")
-
-      image
-    end
+      # Crops a MiniMagick Image from a the given bounding box.
+      #
+      # @param [MiniMagick::Image] image Input Image.
+      # @param [Mindee::Geometry::MinMax] min_max_x minimum & maximum values for the x coordinates.
+      # @param [Mindee::Geometry::MinMax] min_max_y minimum & maximum values for the y coordinates.
+      def self.crop_image(image, min_max_x, min_max_y)
+        width = image[:width].to_i
+        height = image[:height].to_i
+
+        image.format('jpg')
+        new_width = (min_max_x.max - min_max_x.min) * width
+        new_height = (min_max_y.max - min_max_y.min) * height
+        image.crop("#{new_width}x#{new_height}+#{min_max_x.min * width}+#{min_max_y.min * height}")
+
+        image
+      end
 
-    # Writes a MiniMagick::Image to a buffer.
-    #
-    # @param [MiniMagick::Image] image a valid MiniMagick image.
-    # @param [StringIO] buffer
-    def write_image_to_buffer(image, buffer)
-      image.write(buffer)
-    end
+      # Writes a MiniMagick::Image to a buffer.
+      #
+      # @param [MiniMagick::Image] image a valid MiniMagick image.
+      # @param [StringIO] buffer
+      def self.write_image_to_buffer(image, buffer)
+        image.write(buffer)
+      end
 
-    # Retrieves the file extension from the main file to apply it to the extracted images. Note: coerces pdf as jpg.
-    #
-    # @param [Mindee::Input::Source::LocalInputSource] input_source Local input source.
-    # @return [String] A valid file extension.
-    def determine_file_extension(input_source)
-      if input_source.pdf? || input_source.filename.downcase.end_with?('pdf')
-        'jpg'
-      else
-        File.extname(input_source.filename).strip.downcase[1..]
+      # Retrieves the file extension from the main file to apply it to the extracted images. Note: coerces pdf as jpg.
+      #
+      # @param [Mindee::Input::Source::LocalInputSource] input_source Local input source.
+      # @return [String] A valid file extension.
+      def self.determine_file_extension(input_source)
+        if input_source.pdf? || input_source.filename.downcase.end_with?('pdf')
+          'jpg'
+        else
+          File.extname(input_source.filename).strip.downcase[1..]
+        end
       end
-    end
 
-    # Generates an ExtractedImage.
-    #
-    # @param [StringIO] buffer Buffer containing the image.
-    # @param [String] file_name Name for the file.
-    # @param [Object] page_id ID of the page the file was generated from.
-    # @param [Object] element_id ID of the element of a given page.
-    def create_extracted_image(buffer, file_name, page_id, element_id)
-      buffer.rewind
-      ExtractedImage.new(
-        Mindee::Input::Source::BytesInputSource.new(buffer.read, file_name),
-        page_id,
-        element_id
-      )
-    end
+      # Generates an ExtractedImage.
+      #
+      # @param [StringIO] buffer Buffer containing the image.
+      # @param [String] file_name Name for the file.
+      # @param [Object] page_id ID of the page the file was generated from.
+      # @param [Object] element_id ID of the element of a given page.
+      def self.create_extracted_image(buffer, file_name, page_id, element_id)
+        buffer.rewind
+        ExtractedImage.new(
+          Mindee::Input::Source::BytesInputSource.new(buffer.read, file_name),
+          page_id,
+          element_id
+        )
+      end
 
-    # Loads a single_page from an image file or a pdf document.
-    #
-    # @param input_file [LocalInputSource] Local input.
-    # @param [Integer] page_id Page ID.
-    # @return [MiniMagick::Image] A valid PdfDocument handle.
-    def load_doc(input_file, page_id)
-      input_file.io_stream.rewind
-      if input_file.pdf?
-        get_page(Origami::PDF.read(input_file.io_stream), page_id)
-      else
-        input_file.io_stream
+      # Loads a single_page from an image file or a pdf document.
+      #
+      # @param input_file [LocalInputSource] Local input.
+      # @param [Integer] page_id Page ID.
+      # @return [MiniMagick::Image] A valid PdfDocument handle.
+      def self.load_input_source_pdf_page_as_image(input_file, page_id)
+        input_file.io_stream.rewind
+        if input_file.pdf?
+          Mindee::PDF::PdfProcessor.get_page(Origami::PDF.read(input_file.io_stream), page_id)
+        else
+          input_file.io_stream
+        end
       end
     end
   end

data/lib/mindee/extraction/multi_receipts_extractor/multi_receipts_extractor.rb

@@ -1,26 +1,32 @@
 # frozen_string_literal: true
 
+require_relative '../common/image_extractor'
+
 module Mindee
   # Image Extraction Module.
-  module ImageExtraction
-    def extract_receipts(input_source, inference)
-      # Extracts individual receipts from multi-receipts documents.
-      #
-      # @param input_source [LocalInputSource] Local Input Source to extract sub-receipts from.
-      # @param inference [Inference] Results of the inference.
-      # @return [Array<ExtractedImage>] Individual extracted receipts as an array of ExtractedMultiReceiptsImage.
+  module Extraction
+    # Multi-receipts extraction class wrapper.
+    class MultiReceiptsExtractor
+      def self.extract_receipts(input_source, inference)
+        # Extracts individual receipts from multi-receipts documents.
+        #
+        # @param input_source [LocalInputSource] Local Input Source to extract sub-receipts from.
+        # @param inference [Inference] Results of the inference.
+        # @return [Array<ExtractedImage>] Individual extracted receipts as an array of ExtractedMultiReceiptsImage.
 
-      images = []
-      raise 'No possible receipts candidates found for MultiReceipts extraction.' unless inference.prediction.receipts
+        images = []
+        raise 'No possible receipts candidates found for MultiReceipts extraction.' unless inference.prediction.receipts
 
-      (0...input_source.count_pdf_pages).each do |page_id|
-        receipt_positions = inference.pages[page_id].prediction.receipts.map(&:bounding_box)
-        images.concat(
-          extract_multiple_images_from_source(input_source, page_id + 1, receipt_positions)
-        )
-      end
+        (0...input_source.count_pdf_pages).each do |page_id|
+          receipt_positions = inference.pages[page_id].prediction.receipts.map(&:bounding_box)
+          images.concat(
+            Mindee::Extraction::ImageExtractor.extract_multiple_images_from_source(input_source, page_id + 1,
+                                                                                   receipt_positions)
+          )
+        end
 
-      images
+        images
+      end
     end
   end
 end

data/lib/mindee/extraction/pdf_extractor/pdf_extractor.rb

@@ -13,7 +13,7 @@ module Mindee
           if local_input.pdf?
             @source_pdf = local_input.io_stream
           else
-            pdf_image = ImageExtraction.attach_image_as_new_file(local_input.io_stream)
+            pdf_image = Extraction::ImageExtractor.attach_image_as_new_file(local_input.io_stream)
             io_buffer = StringIO.new
             pdf_image.save(io_buffer)
 
@@ -65,6 +65,7 @@ module Mindee
 
         # rubocop:disable Metrics/CyclomaticComplexity
         # rubocop:disable Metrics/PerceivedComplexity
+
         # Extracts invoices as complete PDFs from the document.
         # @param page_indexes [Array<Array<Integer>, InvoiceSplitterV1PageGroup>]
         # @param strict [Boolean]
@@ -99,6 +100,7 @@ module Mindee
           end
           extract_sub_documents(correct_page_indexes)
         end
+
         # rubocop:enable Metrics/CyclomaticComplexity
         # rubocop:enable Metrics/PerceivedComplexity
 

data/lib/mindee/extraction/tax_extractor/tax_extractor.rb

@@ -271,6 +271,7 @@ module Mindee
         end
         candidates
       end
+
       # rubocop:enable Metrics/CyclomaticComplexity
       # rubocop:enable Metrics/PerceivedComplexity
 

data/lib/mindee/geometry/point.rb

@@ -10,9 +10,10 @@ module Mindee
       # @return [Float]
       attr_accessor :y
 
+      # rubocop:disable Naming/MethodParameterName
+
       # @param x [Float]
       # @param y [Float]
-      # rubocop:disable Naming/MethodParameterName
       def initialize(x, y)
         @x = x
         @y = y

data/lib/mindee/image/image_compressor.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Mindee
+  # Image processing module.
+  module Image
+    # Image compressor module to handle image compression.
+    module ImageCompressor
+      # Resize and/or compress an SKBitmap. This assumes the ratio was provided before hands.
+      # @param image [MiniMagick::Image, StringIO] Input image.
+      # @param quality [Integer, nil] Quality of the final file.
+      # @param max_width [Integer, nil] 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.
+      # @return [StringIO]
+      def self.compress_image(image, quality: 85, max_width: nil, max_height: nil)
+        processed_image = ImageUtils.to_image(image)
+        processed_image.format 'jpg'
+        final_width, final_height = ImageUtils.calculate_new_dimensions(
+          processed_image,
+          max_width: max_width,
+          max_height: max_height
+        )
+        ImageUtils.resize_image(processed_image, final_width, final_height) if final_width || final_height
+        ImageUtils.compress_image_quality(processed_image, quality)
+
+        ImageUtils.image_to_stringio(processed_image)
+      end
+    end
+  end
+end

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/date_field.rb

@@ -18,11 +18,15 @@ module Mindee
         # The textual representation of the date as found on the document.
         # @return [String, nil]
         attr_reader :raw
+        # Whether the field was computed or retrieved directly from the document.
+        # @return [Boolean, nil]
+        attr_reader :is_computed
 
         # @param prediction [Hash]
         # @param page_id [Integer, nil]
         def initialize(prediction, page_id)
           super
+          @is_computed = prediction['is_computed']
           return unless @value
 
           @date_object = Date.parse(@value)

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