ruby_marks 0.0.1.dev

data/README.md

@@ -0,0 +1,4 @@
+ruby_marks
+==========
+
+Ruby Marks

data/lib/ruby_marks/clock_mark.rb

@@ -0,0 +1,82 @@
+#encoding: utf-8
+module RubyMarks
+  
+  class ClockMark
+
+    attr_accessor :document, :position, :coordinates
+
+    def initialize(params={})
+      params.each do |k, v|
+        self.send("#{k}=", v) if self.respond_to?("#{k}=")
+      end
+      @coordinates = {x1: 0, x2: 0, y1: 0, y2: 0}
+      self.calc_coordinates
+    end
+
+    def calc_coordinates
+      @coordinates.tap do |coordinates|
+        if self.document
+          x = position[:x]
+          y = position[:y]
+          
+          coordinates[:x1] = x
+          loop do
+            coordinates[:x1] -= 1
+            color = self.document.file.pixel_color(coordinates[:x1], y)
+            color = RubyMarks::RGB.to_hex(color.red, color.green, color.blue)
+
+            break if color != "#000000" || coordinates[:x1] <= 0
+          end
+
+          coordinates[:x2] = x
+          loop do
+            coordinates[:x2] += 1
+            color = self.document.file.pixel_color(coordinates[:x2], y)
+            color = RubyMarks::RGB.to_hex(color.red, color.green, color.blue)
+
+            break if color != "#000000" || coordinates[:x2] >= self.document.file.page.width
+          end 
+
+          coordinates[:y1] = y
+          loop do
+            coordinates[:y1] -= 1
+            color = self.document.file.pixel_color(x, coordinates[:y1])
+            color = RubyMarks::RGB.to_hex(color.red, color.green, color.blue)
+
+            break if color != "#000000" || coordinates[:y1] <= 0
+          end 
+
+          coordinates[:y2] = y
+          loop do
+            coordinates[:y2] += 1
+            color = self.document.file.pixel_color(x, coordinates[:y2])
+            color = RubyMarks::RGB.to_hex(color.red, color.green, color.blue)
+
+            break if color != "#000000" || coordinates[:y2] >= self.document.file.page.height
+          end 
+        end
+      end
+    end
+
+    def width
+      coordinates[:x2] - coordinates[:x1]
+    end    
+
+    def height
+      coordinates[:y2] - coordinates[:y1]
+    end
+
+    def horizontal_middle_position
+      coordinates[:x1] + self.width / 2
+    end
+
+    def vertical_middle_position
+      coordinates[:y1] + self.height / 2
+    end
+
+    def to_s
+      self.coordinates
+    end
+  end
+
+end

data/lib/ruby_marks/document.rb

@@ -0,0 +1,145 @@
+#encoding: utf-8
+module RubyMarks
+  
+  # Represents a scanned document
+  class Document
+
+    attr_reader :file
+
+    attr_accessor :current_position, :clock_marks
+
+    def initialize(file)
+      @file = Magick::Image.read(file).first
+      @current_position = {x: 0, y: 0}
+      @clock_marks = [] 
+    end
+
+    def filename
+      @file.filename
+    end
+
+    def move_to(x, y)
+      @current_position = {x: @current_position[:x] + x, y: @current_position[:y] + y}
+    end
+
+    def marked?
+      if self.current_position
+        area_x = 8
+        area_y = 8
+
+        x_pos = current_position[:x]-area_x..current_position[:x]+area_x
+        y_pos = current_position[:y]-area_y..current_position[:y]+area_y
+
+        colors = []
+
+        y_pos.each do |y|
+          x_pos.each do |x|
+            color = @file.pixel_color(x, y)
+            color = RubyMarks::RGB.to_hex(color.red, color.green, color.blue)
+            color = (color == "#000000") ? "." : " "
+            colors << color
+          end
+        end
+        black_intensity = colors.count(".") * 100 / colors.size
+        return black_intensity >= 40 ? true : false
+      end
+    end
+
+    def unmarked?
+      !marked?
+    end
+
+    def scan
+      result = {}
+      result.tap do |result|
+        position_before = @current_position
+    
+        scan_clock_marks unless clock_marks.any?
+        groups = [87, 310, 535, 760, 985]
+        marks = %w{A B C D E}
+        clock_marks.each_with_index do |clock_mark, index|
+          group_hash = {}
+          groups.each_with_index do |group, index|
+            @current_position = {x: clock_mark.coordinates[:x2], y: clock_mark.vertical_middle_position}
+            move_to(group, 0)
+            markeds = []
+            marks.each do |mark|
+              markeds << mark if marked?
+              move_to(25, 0)
+            end
+            group_hash["group_#{index+1}".to_sym] = markeds if markeds.any?
+          end
+          result["clock_#{index+1}".to_sym] = group_hash if group_hash.any?
+        end
+        @current_position = position_before
+      end
+    end
+
+    def flag_position
+      file = @file.dup
+
+      file.tap do |file|
+        if current_position
+          add_mark file
+        end
+      end
+    end
+
+    def flag_all_marks
+      file = @file.dup
+
+      file.tap do |file|
+        position_before = @current_position
+    
+        scan_clock_marks unless clock_marks.any?
+        groups = [87, 310, 535, 760, 985]
+        marks = %w{A B C D E}
+        clock_marks.each do |clock_mark|
+          groups.each do |group|
+            @current_position = {x: clock_mark.coordinates[:x2], y: clock_mark.vertical_middle_position}
+            move_to(group, 0)
+            marks.each do |mark|
+              add_mark file
+              move_to(25, 0)
+            end
+          end
+        end
+
+        @current_position = position_before
+      end
+    end
+
+    def scan_clock_marks
+      @clock_marks = []
+      x = 62
+      in_clock = false
+      total_height = @file && @file.page.height || 0
+      @clock_marks.tap do |clock_marks| 
+        total_height.times do |y|
+          clock = {}
+          color = @file.pixel_color(x, y)
+          color = RubyMarks::RGB.to_hex(color.red, color.green, color.blue)
+          if !in_clock && color == "#000000"
+            in_clock = true
+            clock_marks << RubyMarks::ClockMark.new(document: self, position: {x: x, y: y+3})
+          elsif in_clock && color != "#000000"
+            in_clock = false
+          end        
+        end
+      end
+    end
+
+    private
+    def add_mark(file)
+      flag = Magick::Draw.new
+      file.annotate(flag, 0, 0, current_position[:x] - 12, current_position[:y] + 15, "+") do
+        self.pointsize = 41
+        self.stroke = '#000000'
+        self.fill = '#C00000'
+        self.font_weight = Magick::BoldWeight
+      end
+    end
+
+  end
+
+end

data/lib/ruby_marks/rgb.rb

@@ -0,0 +1,21 @@
+#encoding: utf-8
+module RubyMarks
+
+  class RGB
+
+    def self.to_hex(red, green, blue)
+      red = get_hex_from_color(red)
+      green = get_hex_from_color(green)
+      blue = get_hex_from_color(blue)
+      "##{red}#{green}#{blue}".upcase
+    end
+
+    private 
+    def self.get_hex_from_color(color)
+      color = color.to_s(16)[0..1]
+      color.size < 2 ? "0#{color}" : color
+    end
+ 
+  end
+
+end

data/lib/ruby_marks/version.rb

@@ -0,0 +1,3 @@
+module RubyMarks
+  VERSION = "0.0.1.dev".freeze
+end

data/lib/ruby_marks.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'RMagick'
+require 'ruby_marks/document'
+require 'ruby_marks/clock_mark'
+require 'ruby_marks/rgb'
+require 'ruby_marks/version'
+
+
+magick_version = `convert -version`
+
+if magick_version =~ /Q16/ 
+  puts %{
+    *** IMPORTANT: You are running the ImageMagick under 16bits quantum depth. This configuration is used
+        in very specific cases and can cause RMagick work a bit slow. See more details in this forum post
+        http://rubyforge.org/forum/forum.php?thread_id=10975&forum_id=1618 ***
+  }
+end

data/test/ruby_marks/clock_mark_test.rb

@@ -0,0 +1,38 @@
+require "test_helper"
+
+class RubyMarks::ClockMarkTest < Test::Unit::TestCase
+
+  def setup 
+    @file = 'assets/sheet_demo1.png'
+    @document = RubyMarks::Document.new(@file)
+    @positions = {}    
+    @positions[:first_clock_position] = {x: 62, y: 794}
+  end
+
+  def test_should_get_clock_coordinates_by_a_given_position
+    clock = RubyMarks::ClockMark.new(document: @document, position: @positions[:first_clock_position])
+    expected_coordinates = {:x1=>48, :x2=>75, :y1=>790, :y2=>802}
+    assert_equal expected_coordinates, clock.calc_coordinates
+  end
+
+  def test_should_obtain_the_clock_mark_width
+    clock = RubyMarks::ClockMark.new(document: @document, position: @positions[:first_clock_position])
+    assert_equal 27, clock.width
+  end
+
+  def test_should_obtain_the_clock_mark_height
+    clock = RubyMarks::ClockMark.new(document: @document, position: @positions[:first_clock_position])
+    assert_equal 12, clock.height
+  end
+
+  def test_should_obtain_the_horizontal_middle_position
+    clock = RubyMarks::ClockMark.new(document: @document, position: @positions[:first_clock_position])
+    assert_equal 61, clock.horizontal_middle_position
+  end  
+
+  def test_should_obtain_the_vertical_middle_position
+    clock = RubyMarks::ClockMark.new(document: @document, position: @positions[:first_clock_position])
+    assert_equal 796, clock.vertical_middle_position
+  end
+
+end

data/test/ruby_marks/document_test.rb

@@ -0,0 +1,88 @@
+require "test_helper"
+
+class RubyMarks::DocumentTest < Test::Unit::TestCase
+  
+  def setup 
+    @file = 'assets/sheet_demo1.png'
+    @document = RubyMarks::Document.new(@file)
+    @positions = {}
+    @positions[:marked_position] = {x: 161, y: 794}
+    @positions[:unmarked_position] = {x: 161, y: 994}
+    @positions[:first_clock_position] = {x: 62, y: 794}
+  end
+
+  def test_should_initialize_a_document_with_a_valid_file
+    assert_equal @file, @document.filename
+  end
+
+  def test_should_return_a_file_with_a_position_flagged
+    @document.current_position = @positions[:first_clock_position]
+    flagged_document = @document.flag_position
+    assert_equal Magick::Image, flagged_document.class
+
+    # temp_filename = "temp_sheet_demo1.png"
+    # File.delete(temp_filename) if File.exist?(temp_filename)
+    # flagged_document.write(temp_filename)
+  end
+
+  def test_should_recognize_marked_position
+    @document.current_position = @positions[:marked_position]
+    assert @document.marked?, "The position wasn't recognized as marked"    
+  end
+
+  def test_should_recognize_not_marked_position
+    @document.current_position = @positions[:unmarked_position]
+    assert @document.unmarked?, "The position wasn't recognized as unmarked"    
+  end
+
+  def test_should_recognize_the_document_clock_marks
+    @document.scan_clock_marks
+    assert_equal 20, @document.clock_marks.count
+  end
+
+  def test_should_return_the_document_with_all_marks_flagged
+    flagged_document = @document.flag_all_marks
+    assert_equal Magick::Image, flagged_document.class
+
+    # temp_filename = "temp_sheet_demo2.png"
+    # File.delete(temp_filename) if File.exist?(temp_filename)
+    # flagged_document.write(temp_filename)    
+  end
+
+  def test_should_move_the_current_position_in_10_and_20_pixels
+    @document.current_position = @positions[:marked_position]
+    expected_position = {x: 171, y: 814}
+
+    assert_equal expected_position, @document.move_to(10, 20)
+  end
+
+  def test_should_scan_the_document_and_get_a_hash_of_marked_marks
+    expected_hash = { 
+      clock_1: {  
+        group_1: ['A'],
+        group_2: ['A']
+      },
+      clock_2: {  
+        group_1: ['B'],
+        group_2: ['B']
+      },
+      clock_3: {  
+        group_1: ['C'],
+        group_2: ['C'],
+        group_3: ['D']        
+      },
+      clock_4: {  
+        group_1: ['D'],
+        group_2: ['D'],
+        group_3: ['D']
+      },
+      clock_5: {  
+        group_1: ['E'],
+        group_2: ['E']
+      }
+    }
+    p @document.scan
+    assert_equal expected_hash, @document.scan 
+  end
+end
+ 

data/test/ruby_marks/rgb_test.rb

@@ -0,0 +1,15 @@
+require "test_helper"
+
+class RubyMarks::RGBTest < Test::Unit::TestCase
+  
+  def test_should_return_the_white_color_in_hexa_receiving_8bits
+    color = RubyMarks::RGB.to_hex(255, 255, 255)
+    assert_equal "#FFFFFF", color
+  end
+
+  def test_should_return_the_white_color_in_hexa_receiving_16bits
+    color = RubyMarks::RGB.to_hex(65535, 65535, 65535)
+    assert_equal "#FFFFFF", color
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+require 'ruby_marks'
+
+$:.unshift File.expand_path("../../assets", __FILE__)

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: ruby_marks
+version: !ruby/object:Gem::Version
+  version: 0.0.1.dev
+  prerelease: 6
+platform: ruby
+authors:
+- André Rodrigues
+- Ronaldo Araujo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple ORM tool
+email: andrerpbts@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/ruby_marks/clock_mark.rb
+- lib/ruby_marks/document.rb
+- lib/ruby_marks/rgb.rb
+- lib/ruby_marks/version.rb
+- lib/ruby_marks.rb
+- test/ruby_marks/clock_mark_test.rb
+- test/ruby_marks/document_test.rb
+- test/ruby_marks/rgb_test.rb
+- test/test_helper.rb
+homepage: https://github.com/andrerpbts/ruby_marks.git
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: ruby_marks
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby Marks ORM
+test_files:
+- test/ruby_marks/clock_mark_test.rb
+- test/ruby_marks/document_test.rb
+- test/ruby_marks/rgb_test.rb
+- test/test_helper.rb