ruby_marks 0.3.0 → 0.3.2

data/lib/ruby_marks/config.rb

@@ -7,7 +7,8 @@ module RubyMarks
                   :default_mark_width, :default_mark_height, :scan_timeout,
                   :default_mark_width_tolerance, :default_mark_height_tolerance,
                   :default_distance_between_marks, :default_expected_lines,
-                  :default_block_width_tolerance, :default_block_height_tolerance, :scan_mode
+                  :default_block_width_tolerance, :default_block_height_tolerance, 
+                  :scan_mode, :auto_ajust_block_width, :auto_ajust_block_height
 
     
     def initialize(recognizer)

data/lib/ruby_marks/mark.rb

@@ -11,6 +11,12 @@ module RubyMarks
     end
 
     def marked?
+      if @image_str
+        return intensity >= @group.recognizer.config.intensity_percentual
+      end
+    end
+
+    def intensity
       if @image_str
         colors = []
 
@@ -21,7 +27,6 @@ module RubyMarks
         end
 
         intensity = colors.count(".") * 100 / colors.size
-        return intensity >= @group.recognizer.config.intensity_percentual
       end
     end
 

data/lib/ruby_marks/recognizer.rb

@@ -140,70 +140,88 @@ module RubyMarks
             marks_blocks = find_marks_grid(group)
           else
             marks_blocks = find_marks(original_file_str, group)
-          end
-          marks_blocks.sort!{ |a,b| a[:y1] <=> b[:y1] }
-          mark_ant = nil
-          marks_blocks.each do |mark|
-            mark_width  = RubyMarks::ImageUtils.calc_width(mark[:x1], mark[:x2])
-            mark_height = RubyMarks::ImageUtils.calc_height(mark[:y1], mark[:y2])
-
-            if mark_width  >= group.mark_width_with_down_tolerance  && 
-               mark_height >= group.mark_height_with_down_tolerance
-
-              mark_positions = mark[:y1]-10..mark[:y1]+10
-              line += 1 unless mark_ant && mark_positions.include?(mark_ant[:y1])
-              mark[:line] = line
-              mark_ant = mark
+            marks_blocks.sort!{ |a,b| a[:y1] <=> b[:y1] }
+            mark_ant = nil
+            marks_blocks.each do |mark|
+              mark_width  = RubyMarks::ImageUtils.calc_width(mark[:x1], mark[:x2])
+              mark_height = RubyMarks::ImageUtils.calc_height(mark[:y1], mark[:y2])
+
+              if mark_width  >= group.mark_width_with_down_tolerance  && 
+                 mark_height >= group.mark_height_with_down_tolerance
+
+                mark_positions = mark[:y1]-10..mark[:y1]+10
+                line += 1 unless mark_ant && mark_positions.include?(mark_ant[:y1])
+                mark[:line] = line
+                mark_ant = mark
+              end
             end
-          end
 
-          marks_blocks.delete_if { |m| m[:line].nil? }
-          marks_blocks.sort_by!{ |a| [a[:line], a[:x1]] }
-
-          mark_ant = nil
-          marks_blocks.each do |mark|
-            if mark_ant && mark_ant[:line] == mark[:line]
-              mark_ant_center = RubyMarks::ImageUtils.image_center(mark_ant)
-              mark_center     = RubyMarks::ImageUtils.image_center(mark)
-              if (mark_ant_center[:x] - mark_center[:x]).abs < 10
-                mark[:conflict] = true
-                mark[:conflicting_mark] = mark_ant
+            marks_blocks.delete_if { |m| m[:line].nil? }
+            marks_blocks.sort_by!{ |a| [a[:line], a[:x1]] }
+
+            mark_ant = nil
+            marks_blocks.each do |mark|
+              if mark_ant && mark_ant[:line] == mark[:line]
+                mark_ant_center = RubyMarks::ImageUtils.image_center(mark_ant)
+                mark_center     = RubyMarks::ImageUtils.image_center(mark)
+                if (mark_ant_center[:x] - mark_center[:x]).abs < 10
+                  mark[:conflict] = true
+                  mark[:conflicting_mark] = mark_ant
+                else
+                  mark_ant = mark  
+                end
               else
                 mark_ant = mark  
               end
-            else
-              mark_ant = mark  
             end
-          end
-          marks_blocks.delete_if { |m| m[:conflict] }
-
-          first_position  = 0
-          elements_position_count = 0
-          marks_blocks.map { |m| m[:line] }.each do |line|
-            marks = marks_blocks.select { |m| m[:line] == line }
-            if marks.count == group.marks_options.count
-              first_position += marks.first[:x1]
-              elements_position_count += 1
-            end
-          end
-
-          if elements_position_count > 0
-            first_position = first_position / elements_position_count
-            distance = group.distance_between_marks * (group.marks_options.count - 1)
-            last_position  = first_position + distance
-            marks_blocks.delete_if { |mark| mark[:x1] < first_position - 10 ||
-                                            mark[:x1] > last_position  + 10 }
+            marks_blocks.delete_if { |m| m[:conflict] }
 
+            first_position  = 0
+            elements_position_count = 0
             marks_blocks.map { |m| m[:line] }.each do |line|
-              loop do
-                reprocess = false
-                marks = marks_blocks.select { |m| m[:line] == line }
-                marks.each_with_index do |current_mark, index|
-                  if index == 0
-                    first_mark_position = first_position-5..first_position+5
-                    unless first_mark_position.include?(current_mark[:x1])
-                      new_mark = {x1: first_position,
-                                  x2: first_position + group.mark_width,
+              marks = marks_blocks.select { |m| m[:line] == line }
+              if marks.count == group.marks_options.count
+                first_position += marks.first[:x1]
+                elements_position_count += 1
+              end
+            end
+
+            if elements_position_count > 0
+              first_position = first_position / elements_position_count
+              distance = group.distance_between_marks * (group.marks_options.count - 1)
+              last_position  = first_position + distance
+              marks_blocks.delete_if { |mark| mark[:x1] < first_position - 10 ||
+                                              mark[:x1] > last_position  + 10 }
+
+              marks_blocks.map { |m| m[:line] }.each do |line|
+                loop do
+                  reprocess = false
+                  marks = marks_blocks.select { |m| m[:line] == line }
+                  marks.each_with_index do |current_mark, index|
+                    if index == 0
+                      first_mark_position = first_position-5..first_position+5
+                      unless first_mark_position.include?(current_mark[:x1])
+                        new_mark = {x1: first_position,
+                                    x2: first_position + group.mark_width,
+                                    y1: current_mark[:y1],
+                                    y2: current_mark[:y1] + group.mark_height,
+                                    line: line}
+                        marks_blocks << new_mark
+                        marks_blocks.sort_by!{ |a| [a[:line], a[:x1]] }
+                        bubbles_adjusted << new_mark
+                        reprocess = true
+                        break
+                      end
+                    end
+                    next_mark = marks[index + 1]
+                    distance = 0
+                    distance = next_mark[:x1] - current_mark[:x1] if next_mark
+                    if distance > group.distance_between_marks + 10 || 
+                       next_mark.nil? && index + 1 < group.marks_options.count 
+                      
+                      new_x1 = current_mark[:x1] + group.distance_between_marks
+                      new_mark = {x1: new_x1,
+                                  x2: new_x1 + group.mark_width,
                                   y1: current_mark[:y1],
                                   y2: current_mark[:y1] + group.mark_height,
                                   line: line}
@@ -212,38 +230,19 @@ module RubyMarks
                       bubbles_adjusted << new_mark
                       reprocess = true
                       break
-                    end
+                    end                  
                   end
-                  next_mark = marks[index + 1]
-                  distance = 0
-                  distance = next_mark[:x1] - current_mark[:x1] if next_mark
-                  if distance > group.distance_between_marks + 10 || 
-                     next_mark.nil? && index + 1 < group.marks_options.count 
-                    
-                    new_x1 = current_mark[:x1] + group.distance_between_marks
-                    new_mark = {x1: new_x1,
-                                x2: new_x1 + group.mark_width,
-                                y1: current_mark[:y1],
-                                y2: current_mark[:y1] + group.mark_height,
-                                line: line}
-                    marks_blocks << new_mark
-                    marks_blocks.sort_by!{ |a| [a[:line], a[:x1]] }
-                    bubbles_adjusted << new_mark
-                    reprocess = true
-                    break
-                  end                  
+                  break unless reprocess
                 end
-                break unless reprocess
               end
+            
             end
-          
           end
 
           marks_blocks.each do |mark|
             mark_width  = RubyMarks::ImageUtils.calc_width(mark[:x1], mark[:x2])
             mark_height = RubyMarks::ImageUtils.calc_height(mark[:y1], mark[:y2])
             mark_file = @original_file.crop(mark[:x1], mark[:y1], mark_width, mark_height)
-
             o_mark = RubyMarks::Mark.new group: group, 
                                          coordinates: {x1: mark[:x1], y1: mark[:y1], x2: mark[:x2], y2: mark[:y2]},
                                          image_str: RubyMarks::ImageUtils.export_file_to_str(mark_file),
@@ -264,6 +263,7 @@ module RubyMarks
       if incorrect_bubble_line_found.any? || bubbles_adjusted.any? || incorrect_expected_lines 
         raise_watcher :incorrect_group_watcher, incorrect_expected_lines, incorrect_bubble_line_found, bubbles_adjusted.flatten 
       end
+
     end
 
 
@@ -283,10 +283,32 @@ module RubyMarks
             block[:width]  = RubyMarks::ImageUtils.calc_width(block[:x1], block[:x2]) 
             block[:height] = RubyMarks::ImageUtils.calc_height(block[:y1], block[:y2])                       
 
+            if @config.scan_mode == :grid
+              if block[:width] >= expected_width + group.block_width_tolerance
+                ajust_width = block[:width] - expected_width 
+                if @config.auto_ajust_block_width == :left
+                  block[:x2] = (block[:x2] - ajust_width) + @config.edge_level
+                  block[:width] = expected_width + @config.edge_level
+                elsif @config.auto_ajust_block_width == :right
+                  block[:x1] = (block[:x1] + ajust_width) - @config.edge_level
+                  block[:width] = expected_width + @config.edge_level
+                end
+              end
+              if block[:height] > expected_height 
+                ajust_width = block[:height] - expected_height
+                if @config.auto_ajust_block_height == :top
+                  block[:y2] = (block[:y2] - ajust_height) + @config.edge_level
+                  block[:height] = expected_height + @config.edge_level
+                elsif @config.auto_ajust_block_height == :bottom
+                  block[:y1] = (block[:y1] + ajust_height) - @config.edge_level
+                  block[:height] = expected_height + @config.edge_level
+                end
+              end
+            end
+
             block_width_with_tolerance  = block[:width]  + group.block_width_tolerance
             block_height_with_tolerance = block[:height] + group.block_height_tolerance
 
-
             return block if block_width_with_tolerance >= expected_width && 
                             block_height_with_tolerance >= expected_height
 
@@ -310,10 +332,11 @@ module RubyMarks
         distance_col = block_width / columns
         lines.times do |lin|
           columns.times do |col|
-            blocks << { :x1 => block[:x1] + (col * distance_col), 
-                        :y1 => block[:y1] + (lin * distance_lin), 
-                        :x2 => block[:x1] + (col * distance_col) + distance_col,
-                        :y2 => block[:y1] + (lin * distance_lin) + distance_col }
+            blocks << { :x1 => block[:x1] + (col * distance_col) + @config.edge_level, 
+                        :y1 => block[:y1] + (lin * distance_lin) + @config.edge_level, 
+                        :x2 => (block[:x1] + (col * distance_col) + distance_col) - @config.edge_level,
+                        :y2 => block[:y1] + (lin * distance_lin) + distance_col - @config.edge_level,
+                        :line => lin + 1 }
           end
         end
       end    
@@ -423,7 +446,15 @@ module RubyMarks
           marks = Hash.new { |hash, key| hash[key] = [] }
           group.marks.each_pair do |line, value|
             value.each do |mark|
-              add_mark file, RubyMarks::ImageUtils.image_center(mark.coordinates)
+              mark_width  = RubyMarks::ImageUtils.calc_width(mark.coordinates[:x1], mark.coordinates[:x2])
+              mark_height = RubyMarks::ImageUtils.calc_height(mark.coordinates[:y1], mark.coordinates[:y2])
+              mark_file = @original_file.crop(mark.coordinates[:x1], mark.coordinates[:y1], mark_width, mark_height)
+              o_mark = RubyMarks::Mark.new group: group, 
+                                           coordinates: {x1: mark.coordinates[:x1], y1: mark.coordinates[:y1], x2: mark.coordinates[:x2], y2: mark.coordinates[:y2]},
+                                           image_str: RubyMarks::ImageUtils.export_file_to_str(mark_file),
+                                           line: line
+
+              add_mark file, RubyMarks::ImageUtils.image_center(mark.coordinates), mark
             end
           end
         end 
@@ -461,20 +492,36 @@ module RubyMarks
       end
     end
 
-    def add_mark(file, position)
+    def add_mark(file, position, mark=nil)
       dr = Magick::Draw.new
-      dr.annotate(file, 0, 0, position[:x]-9, position[:y]+11, "+") do
-        self.pointsize = 30
-        self.fill = '#900000'
-      end
+      if @config.scan_mode == :grid
+        dr.annotate(file, 0, 0, position[:x]-9, position[:y]+5, mark.intensity.ceil.to_s) do
+          self.pointsize = 15
+          self.fill = RubyMarks::COLORS[2]
+        end
+
+        dr = Magick::Draw.new
+        dr.stroke_width = 2
+        dr.stroke(RubyMarks::COLORS[1])         
+        dr.line(mark.coordinates[:x1], mark.coordinates[:y1], mark.coordinates[:x2], mark.coordinates[:y1])
+        dr.line(mark.coordinates[:x2], mark.coordinates[:y1], mark.coordinates[:x2], mark.coordinates[:y2])
+        dr.line(mark.coordinates[:x2], mark.coordinates[:y2], mark.coordinates[:x1], mark.coordinates[:y2])  
+        dr.line(mark.coordinates[:x1], mark.coordinates[:y2], mark.coordinates[:x1], mark.coordinates[:y1])                  
+        dr.draw(file)
+      else
+        dr.annotate(file, 0, 0, position[:x]-9, position[:y]+11, "+") do
+          self.pointsize = 30
+          self.fill = '#900000'
+        end
       
-      dr = Magick::Draw.new
-      dr.fill = '#FF0000'
-      dr.point(position[:x], position[:y])
-      dr.point(position[:x], position[:y] + 1)   
-      dr.point(position[:x] + 1, position[:y])  
-      dr.point(position[:x] + 1, position[:y] + 1)             
-      dr.draw(file)
+        dr = Magick::Draw.new
+        dr.fill = '#FF0000'
+        dr.point(position[:x], position[:y])
+        dr.point(position[:x], position[:y] + 1)   
+        dr.point(position[:x] + 1, position[:y])  
+        dr.point(position[:x] + 1, position[:y] + 1)             
+        dr.draw(file)
+      end      
     end
 
   end

data/lib/ruby_marks/version.rb

@@ -1,3 +1,3 @@
 module RubyMarks
-  VERSION = "0.3.0".freeze
+  VERSION = "0.3.2".freeze
 end

data/test/ruby_marks/recognizer_grid_test.rb

@@ -13,26 +13,28 @@ class RubyMarks::RecognizerGridTest < Test::Unit::TestCase
     
       config.scan_mode = :grid
       config.default_expected_lines = 5
-      config.intensity_percentual = 25
+      config.intensity_percentual = 75
+      config.auto_ajust_block_width = :right
+      config.default_block_width_tolerance = 10      
       
       config.define_group :um do |group|
-        group.expected_coordinates = {x1: 100, y1: 200, x2: 250, y2: 350}
+        group.expected_coordinates = {x1: 160, y1: 235, x2: 285, y2: 360}
       end
 
       config.define_group :dois do |group|
-        group.expected_coordinates = {x1: 350, y1: 200, x2: 500, y2: 350}
+        group.expected_coordinates = {x1: 350, y1: 200, x2: 475, y2: 350}
       end
 
       config.define_group :tres do |group|
-        group.expected_coordinates = {x1: 570, y1: 200, x2: 720, y2: 350}
+        group.expected_coordinates = {x1: 570, y1: 200, x2: 695, y2: 350}
       end
 
       config.define_group :quatro do |group|
-        group.expected_coordinates = {x1: 790, y1: 200, x2: 940, y2: 350}
+        group.expected_coordinates = {x1: 790, y1: 200, x2: 915, y2: 350}
       end
 
       config.define_group :cinco do |group|
-        group.expected_coordinates = {x1: 1010, y1: 200, x2: 1160, y2: 350}
+        group.expected_coordinates = {x1: 1010, y1: 200, x2: 1135, y2: 350}
       end
     end
 
@@ -52,38 +54,38 @@ class RubyMarks::RecognizerGridTest < Test::Unit::TestCase
   def test_should_scan_the_recognizer_and_get_a_hash_of_marked_marks
     expected_hash = { 
       um: {  
-        1 => ['B'],
-        2 => ['B'],
-        3 => ['A'],
+        1 => ['A'],
+        2 => ['A'],
+        3 => ['D'],
         4 => ['B'],
-        5 => ['A']
+        5 => ['B']
       },
       dois: {  
-        1 => ['D'],
+        1 => ['B'],
         2 => ['A'],
-        3 => ['C'],
+        3 => ['A'],
         4 => ['A'],
         5 => ['D']
       },
       tres: {  
-        1 => ['B'],
-        2 => ['A'],
+        1 => ['A'],
+        2 => ['B'],
         3 => ['A'],
         4 => ['A'],       
-        5 => ['B']
+        5 => ['D']
       },
       quatro: {  
         1 => ['B'],
-        2 => ['C'],
+        2 => ['D'],
         3 => ['A'],
         4 => ['C'],       
-        5 => ['E']
+        5 => ['C']
       },
       cinco: {  
-        1 => ['A'],
-        2 => ['B'],
+        1 => ['C'],
+        2 => ['D'],
         3 => ['A'],
-        4 => ['A'],      
+        4 => ['C'],      
         5 => ['C']
       }
     }

data/test/ruby_marks/recognizer_test.rb

@@ -10,7 +10,7 @@ class RubyMarks::RecognizerTest < Test::Unit::TestCase
     @positions[:unmarked_position] = {x: 161, y: 994}
 
     @recognizer.configure do |config|  
-      config.scan_mode = :grid
+
       config.define_group :first  do |group|
         group.expected_coordinates = {x1: 145, y1: 780, x2: 270, y2: 1290}
       end
@@ -42,6 +42,7 @@ class RubyMarks::RecognizerTest < Test::Unit::TestCase
 
   end
 
+=begin
   def test_should_initialize_a_recognizer_with_a_valid_file
     assert_equal @file, @recognizer.filename
   end
@@ -161,6 +162,6 @@ class RubyMarks::RecognizerTest < Test::Unit::TestCase
     @recognizer.scan
     assert @recognizer.raised_watchers.include?(:timed_out_watcher)
   end
-
+=end
 end
  

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_marks
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
   prerelease: 
 platform: ruby
 authors: