shear 0.1.1

data/lib/shear/template_match.rb

@@ -0,0 +1,36 @@
+module Shear
+  class TemplateMatch
+    attr_reader :labels, :words, :error, :transform
+
+    def initialize(_labels, _words, _error, _transform)
+      @labels = _labels
+      @error = _error
+      @words = _words
+      @transform = _transform
+    end
+
+    def [](_key)
+      @labels[_key]
+    end
+
+    def read(_upper_left_pt, _lower_right_pt, line_height: 2.0, exclusion: Set[], delete: false)
+      @words.read(_upper_left_pt,
+        _lower_right_pt,
+        line_height: line_height,
+        exclusion: exclusion,
+        delete: delete)
+    end
+
+    def read_relative(_label, _upper_left_pt, _lower_right_pt, line_height: 2.0, exclusion: Set[],
+      delete: false)
+      ref_pt = @labels[_label]
+      raise ArgumentError, 'invalid label' if ref_pt.nil?
+
+      @words.read(
+        [ref_pt[0] + _upper_left_pt[0], ref_pt[1] + _upper_left_pt[1]],
+        [ref_pt[0] + _lower_right_pt[0], ref_pt[1] + _lower_right_pt[1]],
+        line_height: line_height, exclusion: exclusion, delete: delete
+      )
+    end
+  end
+end

data/lib/shear/version.rb

@@ -0,0 +1,3 @@
+module Shear
+  VERSION = "0.1.1"
+end

data/lib/shear/word_collection.rb

@@ -0,0 +1,157 @@
+require 'matrix'
+require 'active_support'
+
+module Shear
+  class WordCollection
+    class ReadString
+      attr_reader :string, :confidence
+
+      def initialize(_string, _confidence)
+        @string = _string
+        @confidence = _confidence
+      end
+
+      def to_s
+        @string
+      end
+    end
+
+    def self.build_from_url(_url, _google_vision_api_key)
+      word_layout = VisionUtils.get_word_layout(_url, _google_vision_api_key)
+      new.tap do |collection|
+        word_layout.each do |wtext, bounding_box, confidence|
+          collection.push_word(wtext, bounding_box: bounding_box, confidence: confidence)
+        end
+      end
+    end
+
+    attr_reader :words
+
+    def initialize(words = [])
+      @words = words
+    end
+
+    def word(_index)
+      @words[_index][:word]
+    end
+
+    def tl_word(_index)
+      @words[_index][:tl_word]
+    end
+
+    def location(_index)
+      @words[_index][:bounding_box][0]
+    end
+
+    def confidence(_index)
+      @words[_index][:conf]
+    end
+
+    def original_location(_index)
+      @words[_index][:original_bounding_box][0]
+    end
+
+    def bounding_box(_index)
+      @words[_index][:bounding_box]
+    end
+
+    def original_bounding_box(_index)
+      @words[_index][:original_bounding_box]
+    end
+
+    def deleted(_index)
+      @words[_index][:deleted]
+    end
+
+    def count
+      @words.count
+    end
+
+    def push_word(_word, bounding_box:, confidence: 1.0)
+      @words << {
+        word: _word,
+        tl_word: I18n.transliterate(_word).upcase,
+        conf: confidence,
+        bounding_box: bounding_box,
+        original_bounding_box: bounding_box.clone,
+        deleted: false
+      }
+    end
+
+    def search(_word, min_confidence: 0.0)
+      word = I18n.transliterate(_word).upcase
+      @words.each_index.select do |i|
+        @words[i][:tl_word] == word && @words[i][:conf] >= min_confidence
+      end
+    end
+
+    def clone
+      self.class.new.tap do |coll_clone|
+        @words.each do |w|
+          coll_clone.push_word_raw(w)
+        end
+      end
+    end
+
+    def transform!(_matrix)
+      @words.each do |w|
+        w[:original_bounding_box].each_with_index do |vertex, index|
+          new_vertex = (_matrix * Matrix.column_vector(vertex + [1.0])).transpose.to_a.first[0..1]
+          w[:bounding_box][index] = new_vertex
+        end
+      end
+
+      self
+    end
+
+    def read(_upper_left_pt, _lower_right_pt, line_height: 2.0, exclusion: Set[], delete: false,
+      min_confidence: 0)
+      read_words = select_inside_box(
+        _upper_left_pt,
+        _lower_right_pt,
+        min_confidence,
+        exclusion,
+        delete
+      )
+      confidence = read_words.map { |w| w[:conf] }.min || 1.0
+
+      lines = []
+      while !read_words.empty?
+        line_words, read_words = partition_by_line(read_words, line_height)
+
+        lines << line_words.sort_by { |w| w[:bounding_box][0][0] }.map { |w| w[:word] }.join(' ')
+      end
+
+      ReadString.new lines.join("\n"), confidence
+    end
+
+    protected
+
+    def push_word_raw(_raw)
+      @words << _raw
+    end
+
+    def select_inside_box(_upper_left_pt, _lower_right_pt, _min_confidence, _exclusion, _delete)
+      inside_box = []
+      @words.each do |w|
+        next if _exclusion.include? w[:tl_word]
+
+        aabb = { "min": _upper_left_pt, "max": _lower_right_pt }
+        if w[:conf] >= _min_confidence &&
+            BoundingBoxUtils.collides?(aabb, w[:bounding_box]) && !w[:deleted]
+          inside_box << w
+          w[:deleted] = true if _delete
+        end
+      end
+      inside_box
+    end
+
+    def partition_by_line(_words, _line_height)
+      upper_word = _words.min { |a, b| a[:bounding_box][0][1] <=> b[:bounding_box][0][1] }
+
+      _words.partition do |word|
+        word[:bounding_box][0][1] - upper_word[:bounding_box][0][1] < _line_height
+      end
+    end
+  end
+end

data/lib/stencils/base_stencil.rb

@@ -0,0 +1,20 @@
+class BaseStencil
+  def self.match(_word_collection, max_error: default_max_error)
+    template_match = template.match(_word_collection)
+
+    return nil if template_match.nil?
+    return nil if max_error.present? && template_match.error > max_error
+
+    new(template_match).tap &:process_match
+  end
+
+  def self.default_max_error
+    nil
+  end
+
+  attr_reader :match
+
+  def initialize(_match)
+    @match = _match
+  end
+end

data/lib/stencils/example_back_stencil.rb

@@ -0,0 +1,37 @@
+class ExampleBackStencil < BaseStencil
+  def self.template
+    @template ||= Shear::Template.build do |t|
+      t.set 'NAMES', at: [1.3, 0.9]
+      t.set 'DOCUMENT', at: [25.4, 0.8]
+      t.set 'SURNAMES', at: [1.6, 8.0]
+      t.set 'ID', at: [28.9, 8.1]
+    end
+  end
+
+  def self.default_max_error
+    10
+  end
+
+  def face
+    :back
+  end
+
+  def fields
+    @fields ||= Set[
+      "names",
+      "surnames",
+      "has_sensible_data?"
+    ]
+  end
+
+  def has_sensible_data?
+    false
+  end
+
+  attr_reader :names, :surnames
+
+  def process_match
+    @names = match.read([2.5, 4.4], [6.1, 6.2]).to_s
+    @surnames = match.read([2.1, 13.1], [15.0, 15.0]).to_s
+  end
+end

data/lib/stencils/example_front_stencil.rb

@@ -0,0 +1,44 @@
+class ExampleFrontStencil < BaseStencil
+  def self.template
+    @template ||= Shear::Template.build do |t|
+      t.set 'DOCUMENT', at: [0.9, 0.3]
+      t.set 'ID', at: [30.8, 1.2]
+      t.set 'COUNTRY', at: [1.1, 8.1]
+      t.set 'NUMBER', at: [0.8, 15.1]
+    end
+  end
+
+  def face
+    :front
+  end
+
+  def fields
+    @fields ||= Set[
+      "number",
+      "parsed_number",
+      "has_sensible_data?"
+    ]
+  end
+
+  def has_sensible_data?
+    true
+  end
+
+  attr_reader :number, :parsed_number
+
+  def process_match
+    @number = match.read([23.9, 15.0], [34.5, 16.9]).to_s
+    @parsed_number = parse_number(@number)
+  end
+
+  private
+
+  def parse_number(_number)
+    parts = _number.split(".")
+    return nil if parts.length != 3
+
+    return nil if parts.any? { |part| !/\A\d+\z/.match(part) }
+
+    parts.inject { |cumulate, part| cumulate + part }.to_i
+  end
+end

data/lib/stencils/stencil_group.rb

@@ -0,0 +1,40 @@
+class StencilGroup
+  def self.match(_stencil_map, _document_words)
+    stencils = {}
+    _stencil_map.each do |face, stencil|
+      stencils[face] = _document_words.include?(face) ? stencil.match(_document_words[face]) : nil
+    end
+
+    new(stencils)
+  end
+
+  attr_reader :stencils
+
+  def initialize(_stencils)
+    @stencils = _stencils
+  end
+
+  def get_any?(_field)
+    @stencils.values.each do |stencil|
+      raise "#{self.class.name} has no field #{_field}" if !stencil.fields.include? _field
+    end
+
+    @stencils.values.any? { |stencil| stencil.public_send(_field) }
+  end
+
+  def get_all?(_field)
+    @stencils.values.each do |stencil|
+      raise "#{self.class.name} has no field #{_field}" if !stencil.fields.include? _field
+    end
+
+    @stencils.values.all? { |stencil| stencil.public_send(_field) }
+  end
+
+  def get_attribute(_field)
+    @stencils.values.each do |stencil|
+      return stencil.public_send(_field) if stencil.fields.include? _field
+    end
+
+    raise "Unknown field #{_field}"
+  end
+end

data/lib/utils/vision_utils.rb

@@ -0,0 +1,101 @@
+require 'google/cloud/vision'
+require 'faraday_middleware'
+
+module VisionUtils
+  extend self
+
+  def get_word_layout(_url, _api_key, timeout: 30)
+    extract_word_layout handle_response conn(timeout).post(
+      "/v1/images:annotate?key=#{_api_key}",
+      'requests' => [
+        {
+          'image' => build_image_source(_url),
+          'features' => [
+            { 'type' => 'DOCUMENT_TEXT_DETECTION' }
+          ]
+        }
+      ]
+    )
+  end
+
+  private
+
+  def build_image_source(_url)
+    uri = URI(_url)
+    if uri_is_local(uri)
+      { 'content' => Base64.encode64(uri.open(&:read)) }
+    else
+      { 'source' => { 'imageUri': _url } }
+    end
+  end
+
+  def uri_is_local(_uri)
+    return true if _uri.scheme != 'http' && _uri.scheme != 'https'
+
+    _uri.host == 'localhost' || _uri.host == '127.0.0.1'
+  end
+
+  def extract_word_layout(_data)
+    image_text = _data['responses'].first['fullTextAnnotation']
+    return [] if image_text.nil?
+
+    [].tap do |result|
+      image_text['pages'].each do |page|
+        page['blocks'].each do |block|
+          next unless block['blockType'] == 'TEXT'
+
+          block['paragraphs'].each do |para|
+            para['words'].each do |w|
+              extracted_word = extract_word(w)
+              result << extracted_word if extracted_word
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def extract_bounding_box(_vertices)
+    [].tap do |bounding_box|
+      _vertices.each do |vertex|
+        if vertex['x'] == nil || vertex['y'] == nil
+          return nil
+        end
+
+        bounding_box << [vertex['x'], vertex['y']]
+      end
+    end
+  end
+
+  def extract_word(_raw_word)
+    wtext = _raw_word['symbols'].map { |sym| sym['text'] }.join
+    confidence = _raw_word['symbols'].map { |sym| sym['confidence'].to_f }.min
+    vertices = _raw_word['boundingBox']['vertices']
+    bounding_box = extract_bounding_box(vertices)
+
+    if bounding_box == nil
+      return nil
+    end
+
+    [wtext, bounding_box, confidence]
+  end
+
+  def handle_response(_response)
+    if _response.status != 200 && _response.status != 201
+      raise 'Service error'
+    end
+
+    _response.body
+  end
+
+  def conn(_timeout)
+    @conn ||= Faraday.new(url: "https://vision.googleapis.com") do |faraday|
+      faraday.request :json
+      faraday.response :json
+      faraday.adapter :patron
+
+      faraday.options.timeout = _timeout
+      faraday.options.open_timeout = _timeout
+    end
+  end
+end