ruby_marks 0.4.4 → 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NzVhNmU3N2IwMmQ5ZmIzMGUwNTJjNTY3ODU0NzBlMzYwMjU4NjZkNg==
+  data.tar.gz: !binary |-
+    N2NmNGI1OGYwZmFkZWY3OWI2ZmFiMzkwNjkzN2IwNDQ5NjliYzJkYw==
+SHA512:
+  metadata.gz: !binary |-
+    MjMwYzAxMjkwYjg2NDIxZTU5NDE5YzMzMmM0ZTJkOGVjZDIzOGZlYWY1OWYy
+    N2U2OWZlYzNlZDM4ZGU1YmJjYjEzODA1NGM4OTliZjEwMzJjMzIxNDUzMDY2
+    YjY4NDVlYmE1NDQ3ZGE1NzNiZDI0YTEzMDhlZDM1NDhlNjRhNjk=
+  data.tar.gz: !binary |-
+    ZWIxYmRiNzYyMDcxOGM5YWFmZGYzZTFiMDk3Nzk3YzY0MTMwMzExODAxYjQx
+    YzNhN2E3ZGFjODE0MDVhZWFmMWVjZWU5YWQxY2NlMzhmMDQzMGY0MWMwMjVj
+    YjA2ODJlOTU1MjA3NjM3YjI5ZmExYTBlMjg1ZTQ1MThmYzVlNzk=

data/README.md

@@ -2,6 +2,8 @@ Ruby Marks
 ==========
 
 [![Build Status](https://secure.travis-ci.org/andrerpbts/ruby_marks.png?branch=master)](http://travis-ci.org/andrerpbts/ruby_marks)
+[![Code Climate](https://codeclimate.com/github/andrerpbts/ruby_marks/badges/gpa.svg)](https://codeclimate.com/github/andrerpbts/ruby_marks)
+[![Test Coverage](https://codeclimate.com/github/andrerpbts/ruby_marks/badges/coverage.svg)](https://codeclimate.com/github/andrerpbts/ruby_marks)
 
 A simple OMR ([Optical Mark Recognition](http://en.wikipedia.org/wiki/Optical_mark_recognition)) gem for ruby 1.9.x.
 
@@ -489,4 +491,4 @@ Thank you!
 License
 -------
 
-Copyright © 2012 André Rodrigues, Ronaldo Araújo, Rodrigo Virgilio, Lucas Correa. See MIT-LICENSE for further details.
+Copyright © 2012 André Rodrigues, Ronaldo Araújo, Rodrigo Virgilio, Lucas Correa. See MIT-LICENSE for further details.

data/lib/ruby_marks/flood_scan.rb

@@ -2,32 +2,11 @@ module RubyMarks
 
   class FloodScan
 
-    def scan_mark(image, width, height)
-      target = Magick::Pixel.new(0, 0, 0, 0)
-      vx = Hash.new { |hash, key| hash[key] = [] }
-      vy = Hash.new { |hash, key| hash[key] = [] }
-      (1..image.rows).each do |y|
-        (1..image.columns).each do |x|
-          if image.get_pixels(x-1, y-1, 1, 1)[0] == target
-            vx[y] << x
-            vy[x] << y
-          end
-        end
-      end
-      vx = vx.find_mesure(width, 5).max_frequency
-      vy = vy.find_mesure(height, 5).max_frequency
-      if vx && vy
-        {x1: vx[0][0], y1: vy[0][0], x2: vx[0][1], y2: vy[0][1]}
-      else
-        {}
-      end
-    end
-
     def scan(image, node, width, height)
-      target = Magick::Pixel.new(65535, 65535, 65535, 0)
+      target = Magick::Pixel.new(65535, 65535, 65535, 0) 
       replacement = Magick::Pixel.new(0, 0, 0, 0)
       queue = Array.new
-      queue.push(node)
+      queue.push(node) 
       vx = Hash.new { |hash, key| hash[key] = [] }
       vy = Hash.new { |hash, key| hash[key] = [] }
       steps = 0
@@ -38,11 +17,10 @@ module RubyMarks
         span_up = false;
         span_down = false;
         while x > 0 && image.get_pixels(x - 1, y, 1, 1)[0] == target
-          p
           x -= 1
         end
         while x < image.columns && image.get_pixels(x, y, 1, 1)[0] == target
-          image.store_pixels(x, y, 1, 1, [replacement])
+          image.store_pixels(x, y, 1, 1, [replacement]) 
           if !span_up && y > 0 && image.get_pixels(x, y - 1, 1, 1)[0] == target
             queue.push(Magick::Point.new(x, y - 1))
             span_up = true
@@ -55,12 +33,12 @@ module RubyMarks
           elsif span_down && y < image.rows - 1 && image.get_pixels(x, y + 1, 1, 1)[0] != target
             span_down = false
           end
-          vx[y] << x
+          vx[y] << x 
           vy[x] << y
           x += 1
           steps += 1
         end
-        queue.push(Magick::Point.new(x, y - 1)) if queue.empty? && steps < 100
+        queue.push(Magick::Point.new(x, y - 1)) if queue.empty? && steps < 100 
       end
       vx = vx.find_mesure(width, 5).max_frequency
       vy = vy.find_mesure(height, 5).max_frequency

data/lib/ruby_marks/recognizer.rb

@@ -1,8 +1,8 @@
 #encoding: utf-8
 module RubyMarks
-
+  
   class Recognizer
-
+    
     attr_reader   :file, :raised_watchers, :groups, :watchers, :file_str, :original_file_str
     attr_accessor :config, :groups_detected, :groups_not_detected
 
@@ -23,8 +23,8 @@ module RubyMarks
       @original_file_str = nil
 
       @file = Magick::Image.read(file).first
-      @file = @file.quantize(256, Magick::GRAYColorspace)
-      @file = @file.threshold(@config.calculated_threshold_level)
+      @file = @file.quantize(256, Magick::GRAYColorspace)     
+      @file = @file.threshold(@config.calculated_threshold_level) 
       @original_file = @file
       @file = @file.edge(@config.edge_level)
       @groups_detected = false
@@ -32,15 +32,15 @@ module RubyMarks
       @groups.each_pair do |label, group|
         group.marks = nil
         group.marks = Hash.new { |hash, key| hash[key] = [] }
-      end
+      end        
     end
-
+    
 
     def reset_document
       @current_position = {x: 0, y: 0}
       @clock_marks = []
       @raised_watchers = {}
-      @watchers = {}
+      @watchers = {} 
     end
 
 
@@ -56,7 +56,7 @@ module RubyMarks
 
     def configure(&block)
       self.create_config
-      @config.configure(&block)
+      @config.configure(&block) 
     end
 
 
@@ -75,7 +75,7 @@ module RubyMarks
       watcher = @watchers[name]
       if watcher
         @raised_watchers[watcher.name] ||= 0
-        @raised_watchers[watcher.name]  += 1
+        @raised_watchers[watcher.name]  += 1 
         watcher.run(*args)
       end
     end
@@ -83,39 +83,39 @@ module RubyMarks
 
     def scan
       raise IOError, "There's a invalid or missing file" if @file.nil?
-
+      
       unmarked_group_found  = false
       multiple_marked_found = false
 
       result = Hash.new { |hash, key| hash[key] = [] }
       result.tap do |result|
-
-        begin
+ 
+        begin 
           Timeout.timeout(@config.scan_timeout) do
-            self.detect_groups unless @groups_detected
-          end
+            self.detect_groups unless @groups_detected 
+          end        
         rescue Timeout::Error
           raise_watcher :timed_out_watcher
           return result
-        end
+        end       
 
-        @groups.each_pair do |label, group|
+        @groups.each_pair do |label, group|        
           marks = Hash.new { |hash, key| hash[key] = [] }
           group.marks.each_pair do |line, value|
             value.each do |mark|
               marks[line] << mark.value if mark.marked? && mark.value
             end
 
-            multiple_marked_found = true if marks[line].size > 1
+            multiple_marked_found = true if marks[line].size > 1            
             unmarked_group_found  = true if marks[line].empty?
           end
 
-          result[group.label.to_sym] = marks
+          result[group.label.to_sym] = marks 
         end
 
         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
+        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
 
@@ -129,18 +129,16 @@ module RubyMarks
           y = group_center[:y]
           width = RubyMarks::ImageUtils.calc_width(group.expected_coordinates[:x1], group.expected_coordinates[:x2])
           height = RubyMarks::ImageUtils.calc_height(group.expected_coordinates[:y1], group.expected_coordinates[:y2])
-          block = {}
-          while block.empty? && x < group.expected_coordinates[:x2]
-            block = scaner.scan(@file.dup, Magick::Point.new(x += 10, y), width, height)
-          end
+          
+          block = scaner.scan(@file.dup, Magick::Point.new(x, y), width, height)
           if !block.empty?
             group.coordinates = {x1: block[:x1], x2: block[:x2], y1: block[:y1], y2: block[:y2]}
             marks_blocks = find_marks_grid(group)
             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,
+              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),
                                            line: mark[:line]
@@ -173,12 +171,12 @@ module RubyMarks
               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  &&
+              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 if line <= group.expected_lines
+                mark[:line] = line
                 mark_ant = mark
               end
             end
@@ -195,10 +193,10 @@ module RubyMarks
                   mark[:conflict] = true
                   mark[:conflicting_mark] = mark_ant
                 else
-                  mark_ant = mark
+                  mark_ant = mark  
                 end
               else
-                mark_ant = mark
+                mark_ant = mark  
               end
             end
             marks_blocks.delete_if { |m| m[:conflict] }
@@ -243,9 +241,9 @@ module RubyMarks
                     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
-
+                    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,
@@ -257,60 +255,62 @@ module RubyMarks
                       bubbles_adjusted << new_mark
                       reprocess = true
                       break
-                    end
+                    end                  
                   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,
+              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),
                                            line: mark[:line]
-              group.marks[mark[:line]] << o_mark
+              group.marks[mark[:line]] << o_mark if mark[:line] <= group.expected_lines
             end
 
             incorrect_expected_lines = group.incorrect_expected_lines
 
             group.marks.each_pair do |line, marks|
-              if marks.count != group.marks_options.count
+              if marks.count != group.marks_options.count 
                 incorrect_bubble_line_found[group.label.to_sym] << line
               end
-            end
+            end   
           end
-        end
+        end  
         @groups_detected = true
-        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
+        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
     end
 
+
     def find_block_marks(image, x, y, group)
       expected_coordinates = group.expected_coordinates
       found_blocks = []
       expected_width  = RubyMarks::ImageUtils.calc_width(expected_coordinates[:x1], expected_coordinates[:x2])
-      expected_height = RubyMarks::ImageUtils.calc_height(expected_coordinates[:y1], expected_coordinates[:y2])
+      expected_height = RubyMarks::ImageUtils.calc_height(expected_coordinates[:y1], expected_coordinates[:y2]) 
       block = nil
       while x <= expected_coordinates[:x2] && y <= expected_coordinates[:y2]
         if image[y] && image[y][x] == " "
           block = find_in_blocks(found_blocks, x, y)
-          unless block
+          unless block       
             block = find_block(image, x, y)
             found_blocks << block
-
-            block[:width]  = RubyMarks::ImageUtils.calc_width(block[:x1], block[:x2])
-            block[:height] = RubyMarks::ImageUtils.calc_height(block[:y1], block[:y2])
+            
+            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
               unless block[:width] <= (expected_width + group.block_width_tolerance) && block[:width] >= (expected_width - group.block_width_tolerance)
                 if block[:width] > expected_width + group.block_width_tolerance
-                  ajust_width = block[:width] - expected_width
+                  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
@@ -341,12 +341,12 @@ module RubyMarks
             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 &&
+            return block if block_width_with_tolerance >= expected_width && 
                             block_height_with_tolerance >= expected_height
           end
         end
 
-        x += 1
+        x += 1 
         y += 1
       end
     end
@@ -364,14 +364,14 @@ module RubyMarks
         lines.times do |lin|
           columns.times do |col|
 
-            blocks << { :x1 => block[:x1] + (col * distance_col),
-                        :y1 => block[:y1] + (lin * distance_lin),
+            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_lin,
                         :line => lin + 1 }
           end
         end
-      end
+      end    
     end
 
     def find_marks(image, group)
@@ -381,10 +381,10 @@ module RubyMarks
       blocks.tap do |blocks|
         while y < block[:y2]
           x = block[:x1]
-          while x < block[:x2] do
+          while x < block[:x2] do          
             if image[y][x] == " "
               x += 1
-              next
+              next 
             end
 
             result = find_in_blocks(blocks, x, y)
@@ -395,7 +395,7 @@ module RubyMarks
               mark_height = RubyMarks::ImageUtils.calc_height(result[:y1], result[:y2])
 
 
-              if mark_width > group.mark_width_with_up_tolerance
+              if mark_width > group.mark_width_with_up_tolerance  
                 distance_x1 = x - result[:x1]
                 distance_x2 = result[:x2] - x
                 if distance_x1 <= distance_x2
@@ -403,16 +403,16 @@ module RubyMarks
                 else
                   result[:x1] = result[:x2] - group.mark_width
                 end
-              end
-
-              if mark_height > group.mark_height_with_up_tolerance
+              end            
+              
+              if mark_height > group.mark_height_with_up_tolerance  
                 distance_y1 = y - result[:y1]
                 distance_y2 = result[:y2] - y
                 if distance_y1 <= distance_y2
                   result[:y2] = result[:y1] + group.mark_height
                 else
                   result[:y1] = result[:y2] - group.mark_height
-                end
+                end           
               end
 
               blocks << result unless blocks.any? { |b| b == result }
@@ -439,49 +439,57 @@ module RubyMarks
 
     def flag_all_marks
       raise IOError, "There's a invalid or missing file" if @file.nil?
-
+      
       file = @original_file.dup
 
       file.tap do |file|
 
-        begin
+        begin 
           Timeout.timeout(@config.scan_timeout) do
-            self.detect_groups unless @groups_detected
-          end
+            self.detect_groups unless @groups_detected 
+          end        
         rescue Timeout::Error
           raise_watcher :timed_out_watcher
           return file
-        end
+        end  
 
-        @groups.each_pair do |label, group|
+        @groups.each_pair do |label, group|  
 
           dr = Magick::Draw.new
           dr.stroke_width = 5
           dr.stroke(RubyMarks::COLORS[3])
           dr.line(group.expected_coordinates[:x1], group.expected_coordinates[:y1], group.expected_coordinates[:x2], group.expected_coordinates[:y1])
           dr.line(group.expected_coordinates[:x2], group.expected_coordinates[:y1], group.expected_coordinates[:x2], group.expected_coordinates[:y2])
-          dr.line(group.expected_coordinates[:x2], group.expected_coordinates[:y2], group.expected_coordinates[:x1], group.expected_coordinates[:y2])
-          dr.line(group.expected_coordinates[:x1], group.expected_coordinates[:y2], group.expected_coordinates[:x1], group.expected_coordinates[:y1])
+          dr.line(group.expected_coordinates[:x2], group.expected_coordinates[:y2], group.expected_coordinates[:x1], group.expected_coordinates[:y2])  
+          dr.line(group.expected_coordinates[:x1], group.expected_coordinates[:y2], group.expected_coordinates[:x1], group.expected_coordinates[:y1])                  
           dr.draw(file)
 
-          if group.coordinates
+          if group.coordinates 
             dr = Magick::Draw.new
             dr.stroke_width = 5
-            dr.stroke(RubyMarks::COLORS[5])
+            dr.stroke(RubyMarks::COLORS[5])         
             dr.line(group.coordinates[:x1], group.coordinates[:y1], group.coordinates[:x2], group.coordinates[:y1])
             dr.line(group.coordinates[:x2], group.coordinates[:y1], group.coordinates[:x2], group.coordinates[:y2])
-            dr.line(group.coordinates[:x2], group.coordinates[:y2], group.coordinates[:x1], group.coordinates[:y2])
-            dr.line(group.coordinates[:x1], group.coordinates[:y2], group.coordinates[:x1], group.coordinates[:y1])
+            dr.line(group.coordinates[:x2], group.coordinates[:y2], group.coordinates[:x1], group.coordinates[:y2])  
+            dr.line(group.coordinates[:x1], group.coordinates[:y2], group.coordinates[:x1], group.coordinates[:y1])                  
             dr.draw(file)
           end
 
           marks = Hash.new { |hash, key| hash[key] = [] }
           group.marks.each_pair do |line, value|
             value.each do |mark|
+              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
+        end 
       end
     end
 
@@ -511,8 +519,8 @@ module RubyMarks
 
     def find_in_blocks(blocks, x, y)
       blocks.find do |result|
-        result[:x1] <= x && result[:x2] >= x &&
-        result[:y1] <= y && result[:y2] >= y
+        result[:x1] <= x && result[:x2] >= x && 
+        result[:y1] <= y && result[:y2] >= y   
       end
     end
 
@@ -526,26 +534,26 @@ module RubyMarks
 
         dr = Magick::Draw.new
         dr.stroke_width = 2
-        dr.stroke(RubyMarks::COLORS[1])
+        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.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.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
 
   end

data/lib/ruby_marks/version.rb

@@ -1,3 +1,3 @@
 module RubyMarks
-  VERSION = "0.4.4".freeze
-end
+  VERSION = "1.0.0".freeze
+end

data/test/ruby_marks/recognizer_grid_test.rb

@@ -1,7 +1,7 @@
 require "test_helper"
 
 class RubyMarks::RecognizerGridTest < Test::Unit::TestCase
-=begin  
+  
   def setup 
     @file = 'assets/sheet_demo_grid.png'
     @recognizer = RubyMarks::Recognizer.new
@@ -98,5 +98,5 @@ class RubyMarks::RecognizerGridTest < Test::Unit::TestCase
     result.delete_if { |group, lines| lines.empty? }
     assert_equal expected_hash, result 
   end
-=end
+
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_marks
 version: !ruby/object:Gem::Version
-  version: 0.4.4
-  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors:
 - André Rodrigues
@@ -15,7 +14,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rmagick
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
@@ -23,7 +21,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
@@ -37,6 +34,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- lib/ruby_marks.rb
 - lib/ruby_marks/config.rb
 - lib/ruby_marks/flood_scan.rb
 - lib/ruby_marks/group.rb
@@ -46,9 +44,7 @@ files:
 - lib/ruby_marks/support.rb
 - lib/ruby_marks/version.rb
 - lib/ruby_marks/watcher.rb
-- lib/ruby_marks.rb
 - test/ruby_marks/image_utils_test.rb
-- test/ruby_marks/new_grid_test.rb
 - test/ruby_marks/recognizer_grid_test.rb
 - test/ruby_marks/recognizer_test.rb
 - test/ruby_marks/watcher_test.rb
@@ -56,6 +52,7 @@ files:
 homepage: https://github.com/andrerpbts/ruby_marks.git
 licenses:
 - MIT
+metadata: {}
 post_install_message: ! "\n      *** NOTE: You are running the ImageMagick under 16bits
   quantum depth. This configuration is used\n          in very specific cases and
   can cause RMagick work a bit slow. See more details in this forum post\n          http://rubyforge.org/forum/forum.php?thread_id=10975&forum_id=1618
@@ -67,26 +64,23 @@ 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: '0'
 requirements: []
 rubyforge_project: ruby_marks
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A simple OMR tool
 test_files:
 - test/ruby_marks/image_utils_test.rb
-- test/ruby_marks/new_grid_test.rb
 - test/ruby_marks/recognizer_grid_test.rb
 - test/ruby_marks/recognizer_test.rb
 - test/ruby_marks/watcher_test.rb

data/test/ruby_marks/new_grid_test.rb

@@ -1,63 +0,0 @@
-require "test_helper"
-
-class RubyMarks::NewTestGrid < Test::Unit::TestCase
-
-  def setup
-    arquivo = Magick::Image.read('assets/demo2.png').first
-    arquivo = arquivo.deskew 1
-    arquivo.write("temp.jpg")
-    @prova = 'temp.jpg'
-    @recognizer = RubyMarks::Recognizer.new
-    @recognizer.configure do |config|
-      config.scan_mode = :grid
-      config.edge_level = 6
-      config.default_expected_lines = 25
-      config.intensity_percentual = 40
-      config.default_mark_height = 34
-      config.default_mark_width = 34
-      config.default_block_width_tolerance = 10
-      config.scan_timeout = 30
-
-      config.define_group :um do |group|
-        group.expected_coordinates = {x1: 155, y1: 830, x2: 330, y2: 1685}
-        group.expected_lines = 25
-      end
-
-      config.define_group :dois do |group|
-        group.expected_coordinates = {x1: 460, y1: 830, x2: 635, y2: 1685}
-        group.expected_lines = 20
-      end
-
-      config.define_group :tres do |group|
-        group.expected_coordinates = {x1: 765, y1: 830, x2: 940, y2: 1685}
-        group.expected_lines = 25
-      end
-
-      config.define_group :quatro do |group|
-        group.expected_coordinates = {x1: 1070, y1: 830, x2: 1245, y2: 1685}
-        group.expected_lines = 25
-      end
-
-      config.define_group :cinco do |group|
-        group.expected_coordinates = {x1: 1375, y1: 830, x2: 1550, y2: 1685}
-        group.expected_lines = 25
-      end
-    end
-    @recognizer.file = @prova
-    file = @recognizer.flag_all_marks
-    file.write("demo_grid3.png")
-    File.delete("temp.jpg")
-  end
-
-  def test_should_return_correct_marks
-    expected_hash = {
-      um: { 1 => ['E'], 2 => ['E'], 3 => ['B'], 4 => ['D'], 5 => ['E'], 6 => ['E'], 7 => [], 8 => [], 9 => [], 10 => [], 11 => [], 12 => [], 13 => [], 14 => [], 15 => [], 16 => [], 17 => [], 18 => [], 19 => [], 20 => [], 21 => [], 22 => [], 23 => [], 24 => [], 25 => [] },
-      dois: { 1 => [], 2 => [], 3 => [], 4 => [], 5 => [], 6 => [], 7 => [], 8 => [], 9 => [], 10 => [], 11 => [], 12 => [], 13 => [], 14 => [], 15 => [], 16 => [], 17 => [], 18 => [], 19 => [], 20 => [] },
-      tres: { 1 => [], 2 => [], 3 => [], 4 => [], 5 => [], 6 => [], 7 => [], 8 => [], 9 => [], 10 => [], 11 => [], 12 => [], 13 => [], 14 => [], 15 => [], 16 => [], 17 => [], 18 => [], 19 => [], 20 => [], 21 => [], 22 => [], 23 => [], 24 => [], 25 => [] },
-      quatro: { 1 => [], 2 => [], 3 => [], 4 => [], 5 => [], 6 => [], 7 => [], 8 => [], 9 => [], 10 => [], 11 => [], 12 => [], 13 => [], 14 => [], 15 => [], 16 => [], 17 => [], 18 => [], 19 => [], 20 => [], 21 => [], 22 => [], 23 => [], 24 => [], 25 => [] },
-      cinco: { 1 => [], 2 => [], 3 => [], 4 => [], 5 => [], 6 => [], 7 => [], 8 => [], 9 => [], 10 => [], 11 => [], 12 => [], 13 => [], 14 => [], 15 => [], 16 => [], 17 => [], 18 => [], 19 => [], 20 => [], 21 => [], 22 => [], 23 => [], 24 => [], 25 => [] }
-    }
-    result = @recognizer.scan
-    assert_equal expected_hash, result
-  end
-end