percept 0.0.1 → 3.0.0

data/lib/percept/line_collection.rb

@@ -0,0 +1,88 @@
+module Percept
+
+  class LineCollection
+
+    include Enumerable
+
+    attr_accessor :lines
+
+    def initialize(lines = [])
+      self.lines = lines
+    end
+
+    def <<(new_line)
+      merge_line(new_line) || lines << new_line
+    end
+
+    def merge!(other)
+      other.lines.each do |line|
+        self << line
+      end
+      self
+    end
+
+    def split
+      collection = self.class.new
+      lines.each do |line|
+        collection.merge!(line.split)
+      end
+      collection
+    end
+
+    def merge_line(new_line)
+      old_line = lines.detect { |line| line =~ new_line }
+
+      return unless old_line
+
+      old_line.merge!(new_line)
+      true
+    end
+
+    def size
+      lines.size
+    end
+    alias length size
+
+    def each
+      lines.each { |line| yield(line) }
+    end
+
+    def first
+      lines.first
+    end
+
+    def last
+      lines.last
+    end
+
+    def [](index)
+      lines[index]
+    end
+
+    def to_s
+      lines.map(&:to_s).to_s
+    end
+
+    def empty?
+      lines.empty?
+    end
+
+    def remove_unwanted_lines!
+      lines.delete_if { |line| line_filter.filter_line?(line) }
+    end
+
+    def remove_short_lines!
+      lines.delete_if(&:short?)
+    end
+
+    def filtered
+      self.class.new(lines.select { |line| !line_filter.filter_line?(line) })
+    end
+
+    def line_filter
+      LineFilter.new
+    end
+
+  end
+
+end

data/lib/percept/line_detector.rb

@@ -0,0 +1,102 @@
+module Percept
+
+  class LineDetector
+
+    include Percept::Utils
+
+    attr_accessor :image
+
+    def find_lines(row, row_number)
+      start_index = nil
+      lines = LineCollection.new
+
+      row.each_with_index do |pixel, index|
+        if pixel.blackish?
+          start_index ||= index
+        elsif divot?(row, index)
+          next
+        elsif start_index
+          if index - start_index > slope_length
+            lines << Line.new(
+              start_x: start_index,
+              end_x: index,
+              start_y: row_number,
+              row: row,
+              image: image,
+            )
+          end
+          start_index = nil
+        end
+      end
+      lines
+    end
+
+    def detect_lines(image)
+      self.image = image
+      lines = detect_lines_in_rows
+      if lines.empty?
+        Percept.config.maximize_color_tolerance!
+        @columns = nil
+        lines = detect_lines_in_rows
+      end
+      lines.remove_short_lines!
+      lines
+    end
+
+  private
+
+    def detect_lines_in_rows
+      lines = LineCollection.new
+      row_numbers.each do |row_number|
+        row = image.retrieve_row(row_number)
+        lines.merge!(find_lines(row, row_number))
+      end
+      lines
+    end
+
+    def row_numbers
+      row_numbers = []
+      0.upto(image.row_count - 1).each do |row_number|
+        0.upto(columns.size - 2) do |index|
+          left_pixel = columns[index][row_number]
+          right_pixel = columns[index + 1][row_number]
+
+          if left_pixel.blackish? && right_pixel.blackish?
+            row_numbers << row_number
+            break
+          end
+        end
+      end
+      row_numbers
+    end
+
+    def columns
+      @columns ||= collect_columns
+    end
+
+    def collect_columns
+      0.step(image.column_count - 1, line_length / 2).map do |column_number|
+        image.magick_column(column_number)
+      end
+    end
+
+    def line_length
+      Percept.config.line_length
+    end
+
+    def slope_length
+      1.0 / slope
+    end
+
+    def slope
+      1.0 / 20.0
+    end
+
+    def divot?(row, index)
+      row[index + 2] && row[index + 2].blackish? ||
+        row[index + 1] && row[index + 1].blackish?
+    end
+
+  end
+
+end

data/lib/percept/line_filter.rb

@@ -0,0 +1,95 @@
+module Percept
+
+  class LineFilter
+
+    def filter_line?(line)
+      table_top?(line) || top_of_letters?(line) || too_thick?(line)
+    end
+
+    def too_thick?(line)
+      line.height > Percept.config.max_line_height
+    end
+
+    def top_of_letters?(line)
+      blackish_bottom_pixels(line).length.to_f / line.length > 0.20
+    end
+
+    def blackish_bottom_pixels(line)
+      bottom_pixels(line).select(&:blackish?)
+    end
+
+    def bottom_pixels(line)
+      line.columns_for(line.start_x..line.end_x, line.end_y + 1).flatten
+    end
+
+    def left_top_corner?(line)
+      bottom_left_blackish?(line) && !top_left_blackish?(line)
+    end
+
+    def right_top_corner?(line)
+      bottom_right_blackish?(line) && !top_right_blackish?(line)
+    end
+
+    def left_bottom_corner?(line)
+      top_left_blackish?(line) && !bottom_left_blackish?(line)
+    end
+
+    def right_bottom_corner?(line)
+      top_right_blackish?(line) && !bottom_right_blackish?(line)
+    end
+
+    def top_left_blackish?(line)
+      top_left_columns(line).any? { |column| column.all?(&:blackish?) }
+    end
+
+    def bottom_left_blackish?(line)
+      bottom_left_columns(line).any? { |column| column.all?(&:blackish?) }
+    end
+
+    def top_right_blackish?(line)
+      top_right_columns(line).any? { |column| column.all?(&:blackish?) }
+    end
+
+    def bottom_right_blackish?(line)
+      bottom_right_columns(line).any? { |column| column.all?(&:blackish?) }
+    end
+
+    def bottom_left_columns(line)
+      line.columns_for(line.start_x..(line.start_x + 5), line.end_y)
+    end
+
+    def top_left_columns(line)
+      line.columns_for(line.start_x..(line.start_x + 5), line.start_y - 2)
+    end
+
+    def bottom_right_columns(line)
+      line.columns_for((line.end_x - 5)..line.end_x, line.end_y)
+    end
+
+    def top_right_columns(line)
+      line.columns_for((line.end_x - 5)..line.end_x, line.start_y - 2)
+    end
+
+    def table_top?(line)
+      left_top_corner?(line) && right_top_corner?(line)
+    end
+
+    def table_bottom?(line)
+      bottom_corners?(line) && !divided?(line)
+    end
+
+    def bottom_corners?(line)
+      left_bottom_corner?(line) && right_bottom_corner?(line)
+    end
+
+    def divided?(line)
+      line.split.length > 1
+    end
+
+    def table_border?(line)
+      table_top?(line) || table_bottom?(line)
+    end
+
+  end
+
+end

data/lib/percept/pixel.rb

@@ -0,0 +1,28 @@
+module Percept
+
+  class Pixel
+
+    extend Forwardable
+    include Percept::Utils
+    include Percept::PixelUtils
+
+    attr_accessor :selected, :red, :green, :blue
+
+    def initialize(values, selected: false)
+      self.red = values.fetch(:red)
+      self.green = values.fetch(:green)
+      self.blue = values.fetch(:blue)
+      self.selected = selected == true
+    end
+
+    def scale_down(color_value)
+      color_value
+    end
+
+    def scale_up(color_value)
+      color_value
+    end
+
+  end
+
+end

data/lib/percept/pixel_utils.rb

@@ -0,0 +1,73 @@
+module Percept
+
+  module PixelUtils
+
+    attr_accessor :selected
+
+    def scaled_colors
+      [scaled_red, scaled_green, scaled_blue]
+    end
+
+    def blackish?
+      scaled_colors.all? { |color| color <= color_tolerance }
+    end
+
+    def selected?
+      selected
+    end
+
+    def select!
+      self.selected = true
+    end
+
+    def deselect!
+      self.selected = false
+    end
+
+    def to_s
+      symbol.colorize(foreground_color).colorize(background: background_color)
+    end
+
+    def symbol
+      selected? ? '╺╸' : '  '
+    end
+
+    def foreground_color
+      blackish? ? :white : :black
+    end
+
+    def background_color
+      blackish? ? :black : :white
+    end
+
+    def color_tolerance
+      Percept.config.color_tolerance
+    end
+
+    def scaled_red
+      scale_down(red)
+    end
+
+    def scaled_green
+      scale_down(green)
+    end
+
+    def scaled_blue
+      scale_down(blue)
+    end
+
+    def scaled_red=(new_red)
+      self.red = scale_up(new_red)
+    end
+
+    def scaled_green=(new_green)
+      self.green = scale_up(new_green)
+    end
+
+    def scaled_blue=(new_blue)
+      self.blue = scale_up(new_blue)
+    end
+
+  end
+
+end

data/lib/percept/rmagick_image.rb

@@ -0,0 +1,49 @@
+module Percept
+
+  class RMagickImage < Image
+
+    extend Forwardable
+
+    attr_writer :source
+
+    def_delegators :source, :columns, :rows, :store_pixels
+
+    def initialize(file_path)
+      self.file_path = file_path
+    end
+
+    def source
+      @source ||= Magick::Image.read(file_path).first
+    end
+
+    def write(path)
+      dirname = File.dirname(path)
+      FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+      source.write(path)
+    end
+
+    def magick_rows
+      @magick_rows ||= Array.new(row_count) do |row_number|
+        source.get_pixels(0, row_number, column_count, 1)
+      end
+    end
+
+    def pixels
+      magick_rows.flatten
+    end
+
+    def retrieve_pixels(x, y, columns, rows)
+      source.get_pixels(x, y, columns, rows)
+    end
+
+    def row_count
+      rows
+    end
+
+    def column_count
+      columns
+    end
+
+  end
+
+end

data/lib/percept/runner.rb

@@ -1,114 +1,33 @@
 module Percept
 
   class Runner
-    def scaled_color(value)
-      (value * 256) - 1
-    end
-
-    LINE_LENGTH = 50
 
-    def tolerance
-      scaled_color(150)
-    end
-    #def black?(pixel)
-    #  [pixel.red, pixel.green, pixel.blue].all? { |color| color == 0 }
-    #end
-    #
-    def blackish?(pixel)
-      [pixel.red, pixel.green, pixel.blue].all? { |color| color <= tolerance }
-    end
-    out_pixels = []
+    include Percept::Utils
 
-    def highlight_lines!(row)
-      black = false
-      start_index = nil
-      line_indices = []
+    def color_lines(file_path)
+      image = Percept.config.image_class.new(file_path)
+      lines = image.lines
+      lines = lines.split
+      lines.remove_unwanted_lines!
 
-      row.each_with_index do |pixel, index|
-        if blackish?(pixel) && start_index
-          # continue
-        elsif blackish?(pixel) && !start_index
-          start_index = index
-        elsif start_index
-          if index - start_index > LINE_LENGTH
-            line_indices += (start_index...index).to_a
-          end
-          start_index = nil
-        end
+      lines.each do |line|
+        line.color!(255, 0, 0)
       end
 
-      line_indices.each do |index|
-        pixel = row[index]
-        pixel.red = scaled_color(256)
-      end
-      row
+      image.write(Percept.config.output_path)
     end
 
-    def find_lines(row, row_number)
-      start_index = nil
-      lines = []
+    def color_fields(file_path)
+      image = Percept.config.image_class.new(file_path)
+      fields = image.fields
 
-      row.each_with_index do |pixel, index|
-        if blackish?(pixel)
-          start_index ||= index
-        elsif start_index
-          if index - start_index > LINE_LENGTH
-            lines << Line.new(:start_x => start_index, :end_x => index, :row => row, :start_y => row_number)
-          end
-          start_index = nil
-        end
+      fields.each do |field|
+        field.color!(255, 0, 0)
       end
-      lines
-    end
 
-    def each_row(image)
-      column_count = image.columns
-      row_count = image.rows
-      row_count.times do |row_number|
-        row = image.get_pixels(0, row_number, column_count, 1)
-        yield(row, row_number)
-      end
+      image.write(Percept.config.output_path)
     end
 
-    def run
-      images = Magick::ImageList.new('./permission.png')
-      image = images.first
-      #new_image = Magick::Image.new
-
-      rows = image.rows
-      columns = image.columns
-
-      lines = []
-      output_pixels = []
-      each_row(image) do |row, index|
-        output_pixels += row
-        if index % 50 == 0
-          puts "working on row: #{index} of #{rows}"
-        end
-        lines += find_lines(row, index)
-        #out_pixels += highlight_lines!(row)
-        #row.each do |pixel|
-        #  pixel.red = scaled_color(256) if blackish?(pixel)
-        #  out_pixels << pixel
-        #end
-      end
-
-      line_count = lines.count
-      lines.each_with_index do |line, index|
-        puts "coloring line #{index} of #{line_count}"
-        line.pixels.each do |pixel|
-          pixel.red = scaled_color(256)
-        end
-      end
-
-      #image.each_pixel do |pixel, column, row|
-      #  pixel.red = 60000 if blackish?(pixel)
-      #  out_pixels << pixel
-      #end
-
-      image = image.store_pixels(0, 0, columns, rows, output_pixels)
-      image.write('new_permission.png')
-    end
   end
 
 end

data/lib/percept/utils.rb

@@ -0,0 +1,15 @@
+module Percept
+
+  module Utils
+
+    def scaled_color(value)
+      (value * 256) - 1
+    end
+
+    def color_tolerance
+      scaled_color(Percept.config.color_tolerance)
+    end
+
+  end
+
+end

data/lib/percept/version.rb

@@ -1,3 +1,5 @@
 module Percept
-  VERSION = '0.0.1'
+
+  VERSION = '3.0.0'.freeze
+
 end

data/lib/percept.rb

@@ -1,4 +1,43 @@
-require 'RMagick'
+module Percept
+
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.configure
+    yield config if block_given?
+  end
+
+  def self.reset
+    @config = nil
+  end
+
+  def config
+    Percept.config
+  end
+
+end
+
+require 'rmagick'
+require 'forwardable'
+
+require_relative 'percept/utils'
+require_relative 'percept/color_utils'
+require_relative 'percept/config'
+require_relative 'percept/checkbox_field'
+require_relative 'percept/checkbox_collection'
+require_relative 'percept/checkbox_detector'
+require_relative 'percept/field'
+require_relative 'percept/field_collection'
+require_relative 'percept/field_detector'
+require_relative 'percept/pixel_utils'
+require_relative 'ext/rmagick_pixel'
+require_relative 'percept/pixel'
 require_relative 'percept/line'
+require_relative 'percept/line_collection'
+require_relative 'percept/line_filter'
+require_relative 'percept/line_detector'
+require_relative 'percept/image'
+require_relative 'percept/rmagick_image'
 require_relative 'percept/runner'
 require_relative 'percept/version'

data/percept.gemspec

@@ -1,23 +1,22 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'percept/version'
+require_relative 'lib/percept/version'
+require 'English'
 
 Gem::Specification.new do |spec|
   spec.name          = 'percept'
   spec.version       = Percept::VERSION
   spec.authors       = ['Robert Fletcher']
   spec.email         = ['lobatifricha@gmail.com']
-  spec.description   = %q{Detect lines in an image}
-  spec.summary       = %q{Blackish lines for now...}
+  spec.description   = 'Detect lines in an image'
+  spec.summary       = 'Blackish lines for now...'
   spec.homepage      = ''
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(spec)/})
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.3'
-  spec.add_development_dependency 'rake'
+  spec.add_runtime_dependency 'rmagick', '~> 6.1.1'
 end