ruby_marks 0.0.5.dev → 0.1.0

data/README.rdoc

@@ -1,4 +1,4 @@
-= Ruby Marks
+= Ruby Marks {<img src="https://secure.travis-ci.org/andrerpbts/ruby_marks.png" />}[http://travis-ci.org/andrerpbts/ruby_marks]
 
 A simple OMR ({Optical Mark Recognition}[http://en.wikipedia.org/wiki/Optical_mark_recognition]) gem.
 

data/lib/ruby_marks/clock_mark.rb

@@ -3,80 +3,60 @@ module RubyMarks
   
   class ClockMark
 
-    attr_accessor :document, :position, :coordinates
+    attr_accessor :recognizer, :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)
+    def valid?
 
-            break if color != "#000000" || coordinates[:x1] <= 0
-          end
+      return false if !self.recognizer.config.clock_width_tolerance_range.include?(self.width)   ||
+                      !self.recognizer.config.clock_height_tolerance_range.include?(self.height)
+      
+      x_pos = coordinates[:x1]..coordinates[:x2]
+      y_pos = coordinates[:y1]..coordinates[:y2]
 
-          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)
+      colors = []
 
-            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 
+      y_pos.each do |y|
+        x_pos.each do |x|
+          color = self.recognizer.file.pixel_color(x, y)
+          color = RubyMarks::ImageUtils.to_hex(color.red, color.green, color.blue)
+          color = recognizer.config.recognition_colors.include?(color) ? "." : " "
+          colors << color
         end
       end
+
+      intensity = colors.count(".") * 100 / colors.size
+      return intensity >= 70 ? true : false
+    end
+
+    def invalid?
+      !valid?
     end
 
     def width
-      coordinates[:x2] - coordinates[:x1]
+      RubyMarks::ImageUtils.calc_width(@coordinates[:x1], @coordinates[:x2])
     end    
 
     def height
-      coordinates[:y2] - coordinates[:y1]
+      RubyMarks::ImageUtils.calc_height(@coordinates[:y1], @coordinates[:y2])
     end
 
     def horizontal_middle_position
-      coordinates[:x1] + self.width / 2
+      RubyMarks::ImageUtils.calc_middle_horizontal(@coordinates[:x1], self.width)
     end
 
     def vertical_middle_position
-      coordinates[:y1] + self.height / 2
+      RubyMarks::ImageUtils.calc_middle_vertical(@coordinates[:y1], self.height)
     end
 
     def to_s
       self.coordinates
     end
-  end
 
+  end 
 end

data/lib/ruby_marks/config.rb

@@ -3,21 +3,61 @@ module RubyMarks
 
   class Config
 
-    attr_accessor :clock_marks_scan_x, :intensity_percentual, :recognition_colors, :default_marks_options,
-                  :default_distance_between_marks
+    attr_accessor :clock_marks_scan_x, :expected_clocks_count, :intensity_percentual, :recognition_colors,
+                  :default_marks_options, :default_distance_between_marks, 
+                  :clock_width, :clock_height, :threshold_level, :clock_mark_size_tolerance,
+                  :default_mark_width, :default_mark_height
     
-    def initialize(document)
-      @document = document
-      @clock_marks_scan_x = RubyMarks.clock_marks_scan_x
+    def initialize(recognizer)
+      @recognizer = recognizer
+      @threshold_level = RubyMarks.threshold_level
+      
       @intensity_percentual = RubyMarks.intensity_percentual
-      @recognition_colors = RubyMarks.recognition_colors
+      @recognition_colors   = RubyMarks.recognition_colors
+
+      @expected_clocks_count = RubyMarks.expected_clocks_count
+      @clock_marks_scan_x = RubyMarks.clock_marks_scan_x
+      @clock_width  = RubyMarks.clock_width
+      @clock_height = RubyMarks.clock_height
+      @clock_mark_size_tolerance = RubyMarks.clock_mark_size_tolerance
+      
+      @default_mark_width  = RubyMarks.default_mark_width
+      @default_mark_height = RubyMarks.default_mark_height
       @default_marks_options = RubyMarks.default_marks_options
       @default_distance_between_marks = RubyMarks.default_distance_between_marks
     end
 
+    def calculated_threshold_level
+      Magick::QuantumRange * (@threshold_level.to_f / 100)
+    end
+
+    def clock_width_with_down_tolerance
+      @clock_width - @clock_mark_size_tolerance
+    end
+
+    def clock_width_with_up_tolerance
+      @clock_width + @clock_mark_size_tolerance
+    end
+
+    def clock_height_with_down_tolerance
+      @clock_height - @clock_mark_size_tolerance
+    end
+
+    def clock_height_with_up_tolerance
+      @clock_height + @clock_mark_size_tolerance
+    end
+
+    def clock_width_tolerance_range
+      clock_width_with_down_tolerance..clock_width_with_up_tolerance
+    end
+
+    def clock_height_tolerance_range
+      clock_height_with_down_tolerance..clock_height_with_up_tolerance
+    end
+
     def define_group(group_label, &block)
-      group = RubyMarks::Group.new(group_label, @document, &block)
-      @document.add_group(group)
+      group = RubyMarks::Group.new(group_label, @recognizer, &block)
+      @recognizer.add_group(group)
     end
 
     def configure

data/lib/ruby_marks/group.rb

@@ -2,15 +2,18 @@
 module RubyMarks
   
   class Group
+    attr_reader   :label, :recognizer, :clocks_range
 
-    attr_reader :label, :document, :clocks_range
-    attr_accessor :marks_options, :x_distance_from_clock, :distance_between_marks
+    attr_accessor :mark_width, :mark_height, :marks_options, :x_distance_from_clock, 
+                  :distance_between_marks
 
-    def initialize(label, document)
+    def initialize(label, recognizer)
       @label = label
-      @document = document
-      @marks_options = @document.config.default_marks_options
-      @distance_between_marks = @document.config.default_distance_between_marks
+      @recognizer = recognizer
+      @mark_width = @recognizer.config.default_mark_width
+      @mark_height = @recognizer.config.default_mark_height
+      @marks_options = @recognizer.config.default_marks_options
+      @distance_between_marks = @recognizer.config.default_distance_between_marks
       @x_distance_from_clock = 0
       @clocks_range = 0..0
       yield self if block_given?

data/lib/ruby_marks/{rgb.rb → image_utils.rb}

@@ -1,7 +1,24 @@
 #encoding: utf-8
 module RubyMarks
 
-  class RGB
+  class ImageUtils
+
+    def self.calc_width(x1, x2)
+      x2.to_i - x1.to_i + 1
+    end
+
+    def self.calc_height(y1, y2)
+      y2.to_i - y1.to_i + 1
+    end
+
+    def self.calc_middle_horizontal(x, width)
+      x.to_i + width.to_i / 2
+    end
+
+    def self.calc_middle_vertical(y, height)
+      y.to_i + height.to_i / 2
+    end   
+    
 
     def self.to_hex(red, green, blue)
       red = get_hex_from_color(red)

data/lib/ruby_marks/recognizer.rb

@@ -0,0 +1,435 @@
+#encoding: utf-8
+module RubyMarks
+  
+  class Recognizer
+    
+    attr_reader   :file, :raised_watchers, :groups, :watchers
+
+    attr_accessor :current_position, :clock_marks, :config
+
+    def initialize
+      self.reset_document
+      @groups = {}     
+      self.create_config
+    end
+
+    def file=(file)
+      self.reset_document
+      @file = nil
+      @file = Magick::Image.read(file).first
+      @file = @file.threshold(@config.calculated_threshold_level)
+    end
+
+    def reset_document
+      @current_position = {x: 0, y: 0}
+      @clock_marks = []
+      @raised_watchers = []
+      @watchers = {} 
+    end
+
+    def create_config
+      @config ||= RubyMarks::Config.new(self)
+    end
+
+    def filename
+      @file && @file.filename
+    end
+
+    def configure(&block)
+      self.create_config
+      @config.configure(&block) 
+    end
+
+    def add_group(group)
+      @groups[group.label] = group if group
+    end
+
+    def add_watcher(watcher_name, &block)
+      watcher = RubyMarks::Watcher.new(watcher_name, self, &block)
+      @watchers[watcher.name] = watcher if watcher
+    end
+
+    def raise_watcher(name, *args)
+      watcher = @watchers[name]
+      if watcher
+        @raised_watchers << watcher.name unless @raised_watchers.include?(watcher.name)
+        watcher.run(*args)
+      end
+    end
+
+    def move_to(x, y)
+      @current_position = {x: @current_position[:x] + x, y: @current_position[:y] + y}
+    end
+
+    def marked?(expected_width, expected_height)
+      raise IOError, "There's a invalid or missing file" if @file.nil?
+      
+      if self.current_position
+
+        neighborhood_x = current_position[:x]-1..current_position[:x]+1
+        neighborhood_y = current_position[:y]-1..current_position[:y]+1
+
+        neighborhood_y.each do |current_y|
+          neighborhood_x.each do |current_x|
+
+            color = @file.pixel_color(current_x, current_y)
+            color = RubyMarks::ImageUtils.to_hex(color.red, color.green, color.blue)            
+
+            if @config.recognition_colors.include?(color)
+              stack = flood_scan(current_x, current_y)
+
+              x_elements = []
+              y_elements = []
+              stack.each do |k,v|
+                stack[k].inject(x_elements, :<<)
+                y_elements << k
+              end
+
+              x_elements.sort!.uniq!
+              y_elements.sort!.uniq!
+
+              x1 = x_elements.first || 0
+              x2 = x_elements.last  || 0
+              y1 = y_elements.first || 0
+              y2 = y_elements.last  || 0 
+
+              current_width  = RubyMarks::ImageUtils.calc_width(x1, x2)
+              current_height = RubyMarks::ImageUtils.calc_height(y1, y2)
+
+              if current_width >= expected_width + 2
+                distance_x1 = current_x - x1
+                distance_x2 = x2 - current_x
+
+                if distance_x1 <= distance_x2
+                  x2 = x1 + expected_width 
+                else
+                  x1 = x2 - expected_width 
+                end
+                current_width  = RubyMarks::ImageUtils.calc_width(x1, x2)
+              end
+
+
+              if current_height >= expected_height + 2
+                distance_y1 = current_y - y1
+                distance_y2 = y2 - current_y
+
+                if distance_y1 <= distance_y2
+                  y2 = y1 + expected_height 
+                else
+                  y1 = y2 - expected_height  
+                end
+                current_height = RubyMarks::ImageUtils.calc_height(y1, y2)                
+              end
+
+              if (current_width  >= expected_width  - 4 && current_width  <= expected_width  + 4) &&
+                 (current_height >= expected_height - 4 && current_height <= expected_height + 4) 
+
+                colors = []
+
+                x_pos = x1..x2
+                y_pos = y1..y2
+
+                y_pos.each do |y|
+                  x_pos.each do |x|
+                    color = @file.pixel_color(x, y)
+                    color = RubyMarks::ImageUtils.to_hex(color.red, color.green, color.blue)
+                    color = @config.recognition_colors.include?(color) ? "." : " "
+                    colors << color
+                  end
+                end
+
+                intensity = colors.count(".") * 100 / colors.size
+                return true if intensity >= @config.intensity_percentual
+              end
+            end
+         
+          end
+        end
+      end
+
+      return false
+    end
+
+    def unmarked?(x_pos, y_pos)
+      !marked?(x_pos, y_pos)
+    end
+
+    def scan
+      raise IOError, "There's a invalid or missing file" if @file.nil?
+
+      unmarked_group_found  = false
+      multiple_marked_found = false
+
+      result = {}
+      result.tap do |result|
+        position_before = @current_position
+        scan_clock_marks unless clock_marks.any?
+
+        return false if self.config.expected_clocks_count > 0 && @clock_marks.count != self.config.expected_clocks_count
+        clock_marks.each_with_index do |clock_mark, index|
+          group_hash = {}
+          @groups.each do |key, group|
+            if group.belongs_to_clock?(index + 1)
+              @current_position = {x: clock_mark.coordinates[:x2], y: clock_mark.vertical_middle_position}
+              move_to(group.x_distance_from_clock, 0)
+              markeds = []
+              group.marks_options.each do |mark|
+                markeds << mark if marked?(group.mark_width, group.mark_height)
+                move_to(group.distance_between_marks, 0)
+              end
+              if markeds.any?
+                group_hash["group_#{key}".to_sym] = markeds 
+                multiple_marked_found = true if markeds.size > 1
+              else
+                unmarked_group_found = true
+              end
+            end
+          end
+          result["clock_#{index+1}".to_sym] = group_hash if group_hash.any?
+        end
+        @current_position = position_before
+        raise_watcher :scan_unmarked_watcher, result if unmarked_group_found
+        raise_watcher :scan_multiple_marked_watcher, result if multiple_marked_found    
+        raise_watcher :scan_mark_watcher, result, unmarked_group_found, multiple_marked_found if unmarked_group_found || multiple_marked_found    
+      end
+    end
+
+    def flag_position
+
+      raise IOError, "There's a invalid or missing file" if @file.nil?
+
+      file = @file.dup
+
+      file.tap do |file|
+        if current_position
+          add_mark file
+        end
+      end
+    end
+
+    def flag_all_marks
+
+      raise IOError, "There's a invalid or missing file" if @file.nil?
+
+      file = @file.dup
+
+      file.tap do |file|
+        position_before = @current_position
+    
+        scan_clock_marks unless clock_marks.any?
+
+        clock_marks.each_with_index do |clock, index|
+          dr = Magick::Draw.new
+          dr.fill(RubyMarks::COLORS[5])
+          dr.rectangle(clock.coordinates[:x1], clock.coordinates[:y1], clock.coordinates[:x2], clock.coordinates[:y2])
+          dr.draw(file)
+        end
+
+        clock_marks.each_with_index do |clock_mark, index|
+          @groups.each do |key, group|
+            if group.belongs_to_clock?(index + 1)            
+              @current_position = {x: clock_mark.coordinates[:x2], y: clock_mark.vertical_middle_position}
+              move_to(group.x_distance_from_clock, 0)
+              group.marks_options.each do |mark|
+                add_mark file
+                move_to(group.distance_between_marks, 0)
+              end
+            end
+          end
+        end
+
+        @current_position = position_before
+      end
+    end
+
+    def scan_clock_marks
+
+      raise IOError, "There's a invalid or missing file" if @file.nil?
+
+      @clock_marks = []
+      x = @config.clock_marks_scan_x
+      total_height = @file && @file.page.height || 0
+      @clock_marks.tap do |clock_marks|
+        current_y = 0
+        loop do 
+
+          break if current_y > total_height
+
+          color = @file.pixel_color(x, current_y)
+          color = RubyMarks::ImageUtils.to_hex(color.red, color.green, color.blue)
+          
+          if @config.recognition_colors.include?(color)
+            stack = flood_scan(x, current_y)
+
+            x_elements = []
+            y_elements = []
+            stack.each do |k,v|
+              stack[k].inject(x_elements, :<<)
+              y_elements << k
+            end
+
+            x_elements.sort!.uniq!
+            y_elements.sort!.uniq!
+            last_y = y_elements.last
+
+            loop do
+              stack_modified = false
+
+
+              x_elements.each do |col|
+                element_count = 0
+                y_elements.each do |row|
+                  element_count += 1 if stack[row].include?(col)
+                end
+
+                if element_count > 0 && element_count < self.config.clock_height_with_down_tolerance
+                  current_width = RubyMarks::ImageUtils.calc_width(x_elements.first, x_elements.last)                
+                  middle = RubyMarks::ImageUtils.calc_middle_horizontal(x_elements.first, current_width)      
+
+                  x_elements.delete_if do |el|
+                    col <= middle && el <= col || col >= middle && el >= col
+                  end
+
+                  stack_modified = true
+                end
+              end
+
+              y_elements.each do |row|
+                if stack[row].count < self.config.clock_width_with_down_tolerance
+                  current_height = RubyMarks::ImageUtils.calc_height(y_elements.first, y_elements.last)
+                  middle = RubyMarks::ImageUtils.calc_middle_vertical(y_elements.first, current_height)
+
+                  y_elements.delete_if do |ln|
+                    row <= middle  && ln <= row || row >= middle && ln >= row 
+                  end   
+
+                  stack_modified = true
+                end
+              end
+
+              break unless stack_modified
+            end
+
+            x1 = x_elements.first || 0
+            x2 = x_elements.last  || 0
+            y1 = y_elements.first || 0
+            y2 = y_elements.last  || 0 
+          end
+
+          clock = RubyMarks::ClockMark.new(recognizer: self, coordinates: {x1: x1, x2: x2, y1: y1, y2: y2})
+
+          if clock.valid?
+            clock_marks << clock
+            current_y = last_y
+          end
+
+          current_y += 1
+        end
+        raise_watcher :clock_mark_difference_watcher if self.config.expected_clocks_count > 0 && @clock_marks.count != self.config.expected_clocks_count
+      end
+    end
+
+    def flood_scan(x, y)
+      result_mask =  Hash.new { |hash, key| hash[key] = [] }
+      result_mask.tap do |result_mask|
+        process_queue =  Hash.new { |hash, key| hash[key] = [] }
+        process_line = true
+        
+        loop do
+          reset_process = false
+
+          if process_line
+            current_x = x.to_i
+            loop do
+              color = self.file.pixel_color(current_x, y)
+              color = RubyMarks::ImageUtils.to_hex(color.red, color.green, color.blue)
+
+              break if !self.config.recognition_colors.include?(color) || current_x - 1 <= 0            
+              process_queue[y] << current_x unless process_queue[y].include?(current_x) || result_mask[y].include?(current_x) 
+              result_mask[y] << current_x unless result_mask[y].include?(current_x)            
+              current_x = current_x - 1
+            end
+
+            current_x = x.to_i
+            loop do
+              color = self.file.pixel_color(current_x, y)
+              color = RubyMarks::ImageUtils.to_hex(color.red, color.green, color.blue)
+
+              break if !self.config.recognition_colors.include?(color) || current_x + 1 >= self.file.page.width            
+              process_queue[y] << current_x unless process_queue[y].include?(current_x) || result_mask[y].include?(current_x)              
+              result_mask[y] << current_x unless result_mask[y].include?(current_x)
+              current_x = current_x + 1
+            end
+
+            result_mask[y] = result_mask[y].sort
+            process_queue[y] = process_queue[y].sort
+          end
+
+          process_line = true
+
+          process_queue[y].each do |element|
+            if y - 1 >= 0
+              color = self.file.pixel_color(element.to_i, y-1)
+              color = RubyMarks::ImageUtils.to_hex(color.red, color.green, color.blue)     
+              if self.config.recognition_colors.include?(color) && !result_mask[y-1].include?(element)
+                x = element
+                y = y - 1
+                reset_process = true
+                break
+              end
+            end
+          end
+
+          next if reset_process
+
+          process_queue[y].each do |element|         
+            if y + 1 <= self.file.page.height
+              color = self.file.pixel_color(element.to_i, y+1)
+              color = RubyMarks::ImageUtils.to_hex(color.red, color.green, color.blue)
+              if self.config.recognition_colors.include?(color) && !result_mask[y+1].include?(element)
+                x = element
+                y = y + 1
+                reset_process = true
+                break
+              else
+                process_queue[y].delete(element)
+              end
+            end
+          end
+
+          next if reset_process
+
+          process_queue.each do |k,v|
+            process_queue.delete(k) if v.empty?
+          end
+
+          break if process_queue.empty?
+
+          process_line = false
+          y = process_queue.first[0] if process_queue.first.is_a?(Array)
+        end
+      end
+    end
+
+    private
+    def add_mark(file)
+      dr = Magick::Draw.new
+      dr.annotate(file, 0, 0, current_position[:x]-9, current_position[:y]+11, "+") do
+        self.pointsize = 30
+        self.fill = '#900000'
+      end
+      
+      dr = Magick::Draw.new
+      dr.fill = '#FF0000'
+      dr.point(current_position[:x], current_position[:y])
+      dr.point(current_position[:x] + 1, current_position[:y])  
+      dr.point(current_position[:x], current_position[:y] + 1)   
+      dr.point(current_position[:x] + 1, current_position[:y] + 1)             
+      dr.draw(file)
+    end
+
+ 
+
+  end
+
+end

data/lib/ruby_marks/version.rb

@@ -1,3 +1,3 @@
 module RubyMarks
-  VERSION = "0.0.5.dev".freeze
+  VERSION = "0.1.0".freeze
 end

data/lib/ruby_marks/watcher.rb

@@ -0,0 +1,18 @@
+module RubyMarks
+
+  class Watcher
+    attr_reader :name, :recognizer
+
+    def initialize(name, recognizer, &block)
+      raise ArgumentError, "Invalid watcher name" unless RubyMarks::AVAILABLE_WATCHERS.include?(name)
+      @name = name
+      @recognizer = recognizer
+      @action = block
+    end
+
+    def run(*args)
+      @action.call(@recognizer, *args) if @action
+    end
+  end
+
+end

data/lib/ruby_marks.rb

@@ -14,24 +14,56 @@ if magick_version =~ /Q16/
 end
 
 module RubyMarks
+  mattr_accessor :threshold_level
+  @@threshold_level = 60
+
+  mattr_accessor :clock_mark_size_tolerance
+  @@clock_mark_size_tolerance = 2
+
+  mattr_accessor :expected_clocks_count
+  @@expected_clocks_count = 0
+
   mattr_accessor :clock_marks_scan_x
   @@clock_marks_scan_x = 62
 
-  mattr_accessor :intensity_percentual
-  @@intensity_percentual = 40
+  mattr_accessor :clock_width
+  @@clock_width = 26
 
   mattr_accessor :recognition_colors
   @@recognition_colors = ["#000000"]
 
+  mattr_accessor :clock_height
+  @@clock_height = 12
+
+  mattr_accessor :default_mark_width
+  @@default_mark_width = 20
+
+  mattr_accessor :default_mark_height
+  @@default_mark_height = 20
+
+  mattr_accessor :intensity_percentual
+  @@intensity_percentual = 50
+
   mattr_accessor :default_marks_options
   @@default_marks_options = %w{A B C D E}
 
   mattr_accessor :default_distance_between_marks
   @@default_distance_between_marks = 25
+
+  COLORS = %w{ #d80000 #00d8d8 #d8006c #d86c00 #006cd8 #00d86c #d8d800 #00d86c #6c00d8 #a5a500
+               #a27b18 #18a236 #df4f27 }
+
+  AVAILABLE_WATCHERS = [
+    :scan_mark_watcher,
+    :scan_unmarked_watcher,
+    :scan_multiple_marked_watcher,
+    :clock_mark_difference_watcher
+  ]
 end
 
-require 'ruby_marks/document'
-require 'ruby_marks/config'
 require 'ruby_marks/clock_mark'
+require 'ruby_marks/config'
 require 'ruby_marks/group'
-require 'ruby_marks/rgb'
+require 'ruby_marks/image_utils'
+require 'ruby_marks/recognizer'
+require 'ruby_marks/watcher'

data/test/ruby_marks/clock_mark_test.rb

@@ -4,35 +4,41 @@ class RubyMarks::ClockMarkTest < Test::Unit::TestCase
 
   def setup 
     @file = 'assets/sheet_demo1.png'
-    @document = RubyMarks::Document.new(@file)
+    @recognizer = RubyMarks::Recognizer.new
+    @recognizer.file = @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
+    @positions[:first_clock_position] = {x1: 49, x2: 74, y1: 790, y2: 801}
+    @positions[:not_a_clock] = {x1: 62, x2:63, y1: 859, y2: 860}
   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
+    clock = RubyMarks::ClockMark.new(recognizer: @recognizer, coordinates: @positions[:first_clock_position])
+    assert_equal 26, clock.width
   end
 
   def test_should_obtain_the_clock_mark_height
-    clock = RubyMarks::ClockMark.new(document: @document, position: @positions[:first_clock_position])
+    clock = RubyMarks::ClockMark.new(recognizer: @recognizer, coordinates: @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
+    clock = RubyMarks::ClockMark.new(recognizer: @recognizer, coordinates: @positions[:first_clock_position])
+    assert_equal 62, clock.horizontal_middle_position
   end  
 
   def test_should_obtain_the_vertical_middle_position
-    clock = RubyMarks::ClockMark.new(document: @document, position: @positions[:first_clock_position])
+    clock = RubyMarks::ClockMark.new(recognizer: @recognizer, coordinates: @positions[:first_clock_position])
     assert_equal 796, clock.vertical_middle_position
   end
 
+  def test_should_recognize_a_valid_clock
+    clock = RubyMarks::ClockMark.new(recognizer: @recognizer, coordinates: @positions[:first_clock_position])
+    assert clock.valid?, "Not recognized a valid clock"
+  end
+
+  def test_should_recognize_a_invalid_clock
+    clock = RubyMarks::ClockMark.new(recognizer: @recognizer, coordinates: @positions[:not_a_clock])
+    assert clock.invalid?, "Recognized a invalid clock as a valid one"
+  end
+
 end

data/test/ruby_marks/group_test.rb

@@ -4,8 +4,9 @@ class RubyMarks::GroupTest < Test::Unit::TestCase
 
   def setup
     @file = 'assets/sheet_demo1.png'
-    @document = RubyMarks::Document.new(@file)    
-    @group = RubyMarks::Group.new(:test, @document)
+    @recognizer = RubyMarks::Recognizer.new
+    @recognizer.file = @file
+    @group = RubyMarks::Group.new(:test, @recognizer)
   end
 
   def test_should_convert_fixnum_into_range_in_clocks_range

data/test/ruby_marks/{rgb_test.rb → image_utils_test.rb}

@@ -1,14 +1,14 @@
 require "test_helper"
 
-class RubyMarks::RGBTest < Test::Unit::TestCase
+class RubyMarks::ImageUtilsTest < Test::Unit::TestCase
   
   def test_should_return_the_white_color_in_hexa_receiving_8bits
-    color = RubyMarks::RGB.to_hex(255, 255, 255)
+    color = RubyMarks::ImageUtils.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)
+    color = RubyMarks::ImageUtils.to_hex(65535, 65535, 65535)
     assert_equal "#FFFFFF", color
   end
 

data/test/ruby_marks/recognizer_test.rb

@@ -0,0 +1,153 @@
+require "test_helper"
+
+class RubyMarks::RecognizerTest < Test::Unit::TestCase
+  
+  def setup 
+    @file = 'assets/sheet_demo1.png'
+    @recognizer = RubyMarks::Recognizer.new
+    @positions = {}
+    @positions[:marked_position] = {x: 161, y: 794}
+    @positions[:unmarked_position] = {x: 161, y: 994}
+    @positions[:first_clock_position] = {x: 62, y: 794}
+    @positions[:invalid_clock] = {x: 62, y: 1032}
+
+    @recognizer.configure do |config|
+      config.expected_clocks_count = 20
+      config.define_group :first  do |group|
+        group.clocks_range = 1..20 
+        group.x_distance_from_clock = 87
+      end
+
+      config.define_group :second do |group| 
+        group.clocks_range = 1..20         
+        group.x_distance_from_clock = 310
+      end
+
+      config.define_group :third  do |group| 
+        group.clocks_range = 1..20 
+        group.x_distance_from_clock = 535
+      end
+
+      config.define_group :fourth do |group| 
+        group.clocks_range = 1..20 
+        group.x_distance_from_clock = 760
+      end
+
+      config.define_group :fifth  do |group| 
+        group.clocks_range = 1..20 
+        group.x_distance_from_clock = 985
+      end
+    end
+
+    @recognizer.file = @file
+  end
+
+  def test_should_initialize_a_recognizer_with_a_valid_file
+    assert_equal @file, @recognizer.filename
+  end
+
+  def test_should_pass_the_configuration_to_recognizer_config
+    @recognizer.configure do |config|
+      config.clock_marks_scan_x = 30
+    end
+    assert_equal 30, @recognizer.config.clock_marks_scan_x
+  end
+
+  def test_should_get_the_default_configuration_of_config_in_group
+    @recognizer.configure do |config|
+      config.default_marks_options = %w{1 2 3}
+
+      config.define_group :one
+    end
+    assert_equal %w{1 2 3}, @recognizer.groups[:one].marks_options
+  end
+
+  def test_should_get_the_configuration_defined_in_group
+    @recognizer.configure do |config|
+      config.default_marks_options = %w{1 2 3}      
+      config.define_group :one do |group|
+        group.marks_options = %w{X Y Z}
+      end
+    end
+    assert_equal %w{X Y Z}, @recognizer.groups[:one].marks_options
+  end
+
+
+  def test_should_return_a_file_with_a_position_flagged
+    @recognizer.current_position = @positions[:invalid_clock]
+    flagged_recognizer = @recognizer.flag_position
+    assert_equal Magick::Image, flagged_recognizer.class
+
+    # temp_filename = "temp_sheet_demo1.png"
+    # File.delete(temp_filename) if File.exist?(temp_filename)
+    # flagged_recognizer.write(temp_filename)
+  end
+
+  def test_should_recognize_marked_position
+    @recognizer.current_position = @positions[:marked_position]
+    assert @recognizer.marked?(20, 20), "The position wasn't recognized as marked"    
+  end
+
+  def test_should_recognize_not_marked_position
+    @recognizer.current_position = @positions[:unmarked_position]
+    assert @recognizer.unmarked?(20, 20), "The position wasn't recognized as unmarked"    
+  end
+
+  def test_should_recognize_the_recognizer_clock_marks
+    @recognizer.scan_clock_marks
+    assert_equal 20, @recognizer.clock_marks.count
+  end
+
+  def test_should_return_the_recognizer_with_all_marks_flagged
+    flagged_recognizer = @recognizer.flag_all_marks
+    assert_equal Magick::Image, flagged_recognizer.class
+
+    temp_filename = "temp_sheet_demo2.png"
+    File.delete(temp_filename) if File.exist?(temp_filename)
+    flagged_recognizer.write(temp_filename)    
+  end
+
+  def test_should_move_the_current_position_in_10_and_20_pixels
+    @recognizer.current_position = @positions[:marked_position]
+    expected_position = {x: 171, y: 814}
+
+    assert_equal expected_position, @recognizer.move_to(10, 20)
+  end
+
+  def test_should_scan_the_recognizer_and_get_a_hash_of_marked_marks
+    expected_hash = { 
+      clock_1: {  
+        group_first:  ['A'],
+        group_second: ['A']
+      },
+      clock_2: {  
+        group_first:  ['B'],
+        group_second: ['B'],
+        group_third:  ['B']
+      },
+      clock_3: {  
+        group_first:  ['C'],
+        group_second: ['C'], 
+        group_third:  ['D']            
+      },
+      clock_4: {  
+        group_first:  ['D'],
+        group_second: ['D'],
+        group_third:  ['D']       
+      },
+      clock_5: {  
+        group_first:  ['E'],
+        group_second: ['E']
+      }
+    }
+    assert_equal expected_hash, @recognizer.scan 
+  end
+
+  def test_should_make_scan_mark_watcher_raise_up
+    @recognizer.add_watcher :scan_mark_watcher 
+
+    @recognizer.scan
+    assert @recognizer.raised_watchers.include?(:scan_mark_watcher)
+  end
+end
+ 

data/test/ruby_marks/watcher_test.rb

@@ -0,0 +1,11 @@
+require "test_helper"
+
+class RubyMarks::WatcherTest < Test::Unit::TestCase
+
+  def test_should_not_accept_invalid_watchers
+    assert_raise ArgumentError do
+      watcher = RubyMarks::Watcher.new(:some_invalid_watcher_name)
+    end
+  end
+
+end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: ruby_marks
 version: !ruby/object:Gem::Version
-  version: 0.0.5.dev
-  prerelease: 6
+  version: 0.1.0
+  prerelease: 
 platform: ruby
 authors:
 - André Rodrigues
@@ -39,17 +39,19 @@ extra_rdoc_files:
 files:
 - lib/ruby_marks/clock_mark.rb
 - lib/ruby_marks/config.rb
-- lib/ruby_marks/document.rb
 - lib/ruby_marks/group.rb
-- lib/ruby_marks/rgb.rb
+- lib/ruby_marks/image_utils.rb
+- lib/ruby_marks/recognizer.rb
 - lib/ruby_marks/support.rb
 - lib/ruby_marks/version.rb
+- lib/ruby_marks/watcher.rb
 - lib/ruby_marks.rb
 - README.rdoc
 - test/ruby_marks/clock_mark_test.rb
-- test/ruby_marks/document_test.rb
 - test/ruby_marks/group_test.rb
-- test/ruby_marks/rgb_test.rb
+- test/ruby_marks/image_utils_test.rb
+- test/ruby_marks/recognizer_test.rb
+- test/ruby_marks/watcher_test.rb
 - test/test_helper.rb
 homepage: https://github.com/andrerpbts/ruby_marks.git
 licenses:
@@ -67,9 +69,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: ruby_marks
 rubygems_version: 1.8.24
@@ -78,7 +80,8 @@ specification_version: 3
 summary: A simple OMR tool
 test_files:
 - test/ruby_marks/clock_mark_test.rb
-- test/ruby_marks/document_test.rb
 - test/ruby_marks/group_test.rb
-- test/ruby_marks/rgb_test.rb
+- test/ruby_marks/image_utils_test.rb
+- test/ruby_marks/recognizer_test.rb
+- test/ruby_marks/watcher_test.rb
 - test/test_helper.rb

data/lib/ruby_marks/document.rb

@@ -1,161 +0,0 @@
-#encoding: utf-8
-module RubyMarks
-  
-  # Represents a scanned document
-  class Document
-
-    attr_reader :file
-
-    attr_accessor :current_position, :clock_marks, :config, :groups
-
-    def initialize(file)
-      @file = Magick::Image.read(file).first
-      @current_position = {x: 0, y: 0}
-      @clock_marks = []
-      @groups = {} 
-      self.create_config
-    end
-
-    def create_config
-      @config ||= RubyMarks::Config.new(self)
-    end
-
-    def filename
-      @file.filename
-    end
-
-    def configure(&block)
-      self.create_config
-      @config.configure(&block) 
-    end
-
-    def add_group(group)
-      @groups[group.label] = group if group
-    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 = @config.recognition_colors.include?(color) ? "." : " "
-            colors << color
-          end
-        end
-        intensity = colors.count(".") * 100 / colors.size
-        return intensity >= @config.intensity_percentual ? 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?
-    
-        clock_marks.each_with_index do |clock_mark, index|
-          group_hash = {}
-          @groups.each do |key, group|
-            if group.belongs_to_clock?(index + 1)
-              @current_position = {x: clock_mark.coordinates[:x2], y: clock_mark.vertical_middle_position}
-              move_to(group.x_distance_from_clock, 0)
-              markeds = []
-              group.marks_options.each do |mark|
-                markeds << mark if marked?
-                move_to(group.distance_between_marks, 0)
-              end
-              group_hash["group_#{key}".to_sym] = markeds if markeds.any?
-            end
-          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?
-
-        clock_marks.each_with_index do |clock_mark, index|
-          @groups.each do |key, group|
-            if group.belongs_to_clock?(index + 1)            
-              @current_position = {x: clock_mark.coordinates[:x2], y: clock_mark.vertical_middle_position}
-              move_to(group.x_distance_from_clock, 0)
-              group.marks_options.each do |mark|
-                add_mark file
-                move_to(group.distance_between_marks, 0)
-              end
-            end
-          end
-        end
-
-        @current_position = position_before
-      end
-    end
-
-    def scan_clock_marks
-      @clock_marks = []
-      x = @config.clock_marks_scan_x
-      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/test/ruby_marks/document_test.rb

@@ -1,141 +0,0 @@
-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}
-
-    @document.configure do |config|
-      config.define_group :first  do |group|
-        group.clocks_range = 1..20 
-        group.x_distance_from_clock = 87
-      end
-
-      config.define_group :second do |group| 
-        group.clocks_range = 1..20         
-        group.x_distance_from_clock = 310
-      end
-
-      config.define_group :third  do |group| 
-        group.clocks_range = 1..20 
-        group.x_distance_from_clock = 535
-      end
-
-      config.define_group :fourth do |group| 
-        group.clocks_range = 1..20 
-        group.x_distance_from_clock = 760
-      end
-
-      config.define_group :fifth  do |group| 
-        group.clocks_range = 1..20 
-        group.x_distance_from_clock = 985
-      end
-    end
-  end
-
-  def test_should_initialize_a_document_with_a_valid_file
-    assert_equal @file, @document.filename
-  end
-
-  def test_should_pass_the_configuration_to_document_config
-    @document.configure do |config|
-      config.clock_marks_scan_x = 30
-    end
-    assert_equal 30, @document.config.clock_marks_scan_x
-  end
-
-  def test_should_get_the_default_configuration_of_config_in_group
-    @document.configure do |config|
-      config.default_marks_options = %w{1 2 3}
-
-      config.define_group :one
-    end
-    assert_equal %w{1 2 3}, @document.groups[:one].marks_options
-  end
-
-  def test_should_get_the_configuration_defined_in_group
-    @document.configure do |config|
-      config.default_marks_options = %w{1 2 3}      
-      config.define_group :one do |group|
-        group.marks_options = %w{X Y Z}
-      end
-    end
-    assert_equal %w{X Y Z}, @document.groups[:one].marks_options
-  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_first:  ['A'],
-        group_second: ['A']
-      },
-      clock_2: {  
-        group_first:  ['B'],
-        group_second: ['B']
-      },
-      clock_3: {  
-        group_first:  ['C'],
-        group_second: ['C'],
-        group_third:  ['D']        
-      },
-      clock_4: {  
-        group_first:  ['D'],
-        group_second: ['D'],
-        group_third:  ['D']
-      },
-      clock_5: {  
-        group_first:  ['E'],
-        group_second: ['E']
-      }
-    }
-    assert_equal expected_hash, @document.scan 
-  end
-end
-