ruby_marks 0.3.5 → 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 37a5334e1a3c2ea8f16932a3e7a6717169c44992
+  data.tar.gz: 8b3c73f1b8ad991af9a8d31d138c30d630faa616
+SHA512:
+  metadata.gz: a82005142fcfd71856f789ba472bf8c40ec10fac8e5896d28443f5adc147c7f1f3d5683add03fd16f786f87a32642e473d782c4c518b1bd92434f2b6177c7045
+  data.tar.gz: 4daa86c2fc1a53c61c355436b14ce56694bf760e1a38605f637a9bc0e0e6fed9d7fe087965b2318455a7315a247000e96a3377c980fa81a07839e9b366934a3b

data/lib/ruby_marks/flood_scan.rb

@@ -0,0 +1,53 @@
+module RubyMarks
+
+  class FloodScan
+
+    def scan(image, node, width, height)
+      target = Magick::Pixel.new(65535, 65535, 65535, 0) 
+      replacement = Magick::Pixel.new(0, 0, 0, 0)
+      queue = Array.new
+      queue.push(node) 
+      vx = Hash.new { |hash, key| hash[key] = [] }
+      vy = Hash.new { |hash, key| hash[key] = [] }
+      steps = 0
+      until queue.empty?
+        node = queue.shift
+        x = node.x
+        y = node.y
+        span_up = false;
+        span_down = false;
+        while x > 0 && image.get_pixels(x - 1, y, 1, 1)[0] == target
+          x -= 1
+        end
+        while x < image.columns && image.get_pixels(x, y, 1, 1)[0] == target
+          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
+          elsif span_up && y > 0 && image.get_pixels(x, y - 1, 1, 1)[0] != target
+            span_up = false
+          end
+          if !span_down && y < image.rows - 1 && image.get_pixels(x, y + 1, 1, 1)[0] == target
+            queue.push(Magick::Point.new(x, y + 1))
+            span_down = true
+          elsif span_down && y < image.rows - 1 && image.get_pixels(x, y + 1, 1, 1)[0] != target
+            span_down = false
+          end
+          vx[y] << x 
+          vy[x] << y
+          x += 1
+          steps += 1
+        end
+        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
+      if vx && vy
+        {x1: vx[0][0], y1: vy[0][0], x2: vx[0][1], y2: vy[0][1]}
+      else
+        {}
+      end
+    end
+  end
+
+end

data/lib/ruby_marks/recognizer.rb

@@ -119,26 +119,48 @@ module RubyMarks
     end
 
 
-    def detect_groups    
-      file_str = RubyMarks::ImageUtils.export_file_to_str(@file)
-      original_file_str = RubyMarks::ImageUtils.export_file_to_str(@original_file)
-      incorrect_bubble_line_found = Hash.new { |hash, key| hash[key] = [] }
-      bubbles_adjusted = []
-      incorrect_expected_lines = false
+    def detect_groups
+      if @config.scan_mode == :grid
+        scaner = RubyMarks::FloodScan.new
+        @groups.each_pair do |label, group|
+          group_center = RubyMarks::ImageUtils.image_center(group.expected_coordinates)
+          x = group_center[:x]
+          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 = scaner.scan(@file.dup, Magick::Point.new(x, y), width, height)
+          if block
+            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, 
+                                           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
+            end            
+          end
+        end
+      else
+        file_str = RubyMarks::ImageUtils.export_file_to_str(@file)
+        original_file_str = RubyMarks::ImageUtils.export_file_to_str(@original_file)
+        incorrect_bubble_line_found = Hash.new { |hash, key| hash[key] = [] }
+        bubbles_adjusted = []
+        incorrect_expected_lines = false
 
-      @groups.each_pair do |label, group|
-        next unless group.expected_coordinates.any?
+        @groups.each_pair do |label, group|
+          next unless group.expected_coordinates.any?
 
-        line = 0
-        group_center = RubyMarks::ImageUtils.image_center(group.expected_coordinates)
+          line = 0
+          group_center = RubyMarks::ImageUtils.image_center(group.expected_coordinates)
 
-        block = find_block_marks(file_str, group_center[:x], group_center[:y], group)
-        if block
-          group.coordinates = {x1: block[:x1], x2: block[:x2], y1: block[:y1], y2: block[:y2]}
-          
-          if @config.scan_mode == :grid
-            marks_blocks = find_marks_grid(group)
-          else
+          block = find_block_marks(file_str, group_center[:x], group_center[:y], group)
+          if block
+            group.coordinates = {x1: block[:x1], x2: block[:x2], y1: block[:y1], y2: block[:y2]}
             marks_blocks = find_marks(original_file_str, group)
             marks_blocks.sort!{ |a,b| a[:y1] <=> b[:y1] }
             mark_ant = nil
@@ -237,33 +259,32 @@ module RubyMarks
               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),
-                                         line: mark[:line]
-            group.marks[mark[:line]] << o_mark
-          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),
+                                           line: mark[:line]
+              group.marks[mark[:line]] << o_mark
+            end
 
-          incorrect_expected_lines = group.incorrect_expected_lines
+            incorrect_expected_lines = group.incorrect_expected_lines
 
-          group.marks.each_pair do |line, marks|
-            if marks.count != group.marks_options.count 
-              incorrect_bubble_line_found[group.label.to_sym] << line
-            end
-          end   
+            group.marks.each_pair do |line, marks|
+              if marks.count != group.marks_options.count 
+                incorrect_bubble_line_found[group.label.to_sym] << line
+              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 
         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 
       end
-
     end
 
 
@@ -281,27 +302,35 @@ module RubyMarks
             found_blocks << block
             
             block[:width]  = RubyMarks::ImageUtils.calc_width(block[:x1], block[:x2]) 
-            block[:height] = RubyMarks::ImageUtils.calc_height(block[:y1], block[:y2])                       
+            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
+              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 
+                  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
+                else
+                  block[:width] = 0
                 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
+              unless block[:height] <= (expected_height + group.block_height_tolerance) && block[:height] >= (expected_height - group.block_height_tolerance)
+                if block[:height] > expected_height + group.block_height_tolerance
+                  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
+                else
+                  block[:height] = 0
                 end
               end
             end
@@ -311,7 +340,6 @@ module RubyMarks
 
             return block if block_width_with_tolerance >= expected_width && 
                             block_height_with_tolerance >= expected_height
-
           end
         end
 
@@ -327,16 +355,16 @@ module RubyMarks
         block_width  = RubyMarks::ImageUtils.calc_width(block[:x1], block[:x2])
         block_height = RubyMarks::ImageUtils.calc_height(block[:y1], block[:y2])
         lines   = group.expected_lines
-        columns = @config.default_marks_options.size
-        distance_lin = @config.default_mark_height
-        distance_col = @config.default_mark_width
+        columns = group.marks_options.size
+        distance_lin = (block_height / lines).ceil 
+        distance_col = (block_width / columns).ceil
         lines.times do |lin|
           columns.times do |col|
 
-            blocks << { :x1 => @config.edge_level + block[:x1] + (col * distance_col) + ((col % 2 == 1) ? 0 : 1), 
-                        :y1 => @config.edge_level + block[:y1] + (lin * distance_lin) + ((lin % 2 == 1) ? 0 : 1), 
-                        :x2 => @config.edge_level + block[:x1] + (col * distance_col) + distance_col + ((col % 2 == 1) ? 0 : 1),
-                        :y2 => @config.edge_level + block[:y1] + (lin * distance_lin) + distance_lin + ((lin % 2 == 1) ? 0 : 1),
+            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
@@ -419,7 +447,7 @@ module RubyMarks
           end        
         rescue Timeout::Error
           raise_watcher :timed_out_watcher
-          return false
+          return file
         end  
 
         @groups.each_pair do |label, group|  
@@ -496,7 +524,7 @@ module RubyMarks
     def add_mark(file, position, mark=nil)
       dr = Magick::Draw.new
       if @config.scan_mode == :grid
-        dr.annotate(file, 0, 0, position[:x]-9, position[:y]+5, mark.intensity.ceil.to_s) do
+        dr.annotate(file, 0, 0, position[:x]-9, position[:y]+5, mark.intensity ? mark.intensity.ceil.to_s : '+' ) do
           self.pointsize = 15
           self.fill = RubyMarks::COLORS[2]
         end

data/lib/ruby_marks/version.rb

@@ -1,3 +1,3 @@
 module RubyMarks
-  VERSION = "0.3.5".freeze
+  VERSION = "0.4.0".freeze
 end

data/lib/ruby_marks.rb

@@ -68,9 +68,36 @@ module RubyMarks
   ]
 end
 
+class Array
+  def to_ranges
+    compact.sort.uniq.inject([]) do |r,x|
+      r.empty? || r.last.last.succ != x ? r << [x,x] : r[0..-2] << [r.last.first, x]
+    end
+  end
+
+  def max_frequency
+    group_by{ |w| w }
+    .map{ |w, v| [w, v.size] }
+    .max { |a, b| a[1] <=> b[1] }
+  end
+end
+
+class Hash
+  def find_mesure(measure, tolerance)
+    ax = []
+    each do |k, v|
+      max = v.max { |a, b| a <=> b }
+      min = v.min { |a, b| a <=> b }
+      ax << [min, max] if max - min >= measure - tolerance && max - min <= measure + tolerance 
+    end
+    ax  
+  end
+end
+
 require 'ruby_marks/config'
 require 'ruby_marks/group'
 require 'ruby_marks/image_utils'
 require 'ruby_marks/mark'
 require 'ruby_marks/recognizer'
-require 'ruby_marks/watcher'
+require 'ruby_marks/watcher'
+require 'ruby_marks/flood_scan'

data/test/ruby_marks/recognizer_grid_test.rb

@@ -5,15 +5,13 @@ class RubyMarks::RecognizerGridTest < Test::Unit::TestCase
   def setup 
     @file = 'assets/sheet_demo_grid.png'
     @recognizer = RubyMarks::Recognizer.new
-    @positions = {}
-    @positions[:marked_position] = {x: 161, y: 794}
-    @positions[:unmarked_position] = {x: 161, y: 994}
 
     @recognizer.configure do |config|  
     
       config.scan_mode = :grid
+      config.edge_level = 4
       config.default_expected_lines = 5
-      config.intensity_percentual = 50
+      config.intensity_percentual = 45
       config.default_mark_height = 25
       config.default_mark_width = 25
       config.auto_ajust_block_width = :right
@@ -24,24 +22,26 @@ class RubyMarks::RecognizerGridTest < Test::Unit::TestCase
       end
 
       config.define_group :dois do |group|
-        group.expected_coordinates = {x1: 350, y1: 200, x2: 475, y2: 350}
+        group.expected_coordinates = {x1: 350, y1: 235, x2: 475, y2: 360}
       end
 
       config.define_group :tres do |group|
-        group.expected_coordinates = {x1: 570, y1: 200, x2: 695, y2: 350}
+        group.expected_coordinates = {x1: 570, y1: 235, x2: 695, y2: 360}
       end
 
       config.define_group :quatro do |group|
-        group.expected_coordinates = {x1: 790, y1: 200, x2: 915, y2: 350}
+        group.expected_coordinates = {x1: 790, y1: 235, x2: 915, y2: 360}
       end
 
       config.define_group :cinco do |group|
-        group.expected_coordinates = {x1: 1010, y1: 200, x2: 1135, y2: 350}
+        group.expected_coordinates = {x1: 1010, y1: 235, x2: 1135, y2: 360}
       end
     end
 
     @recognizer.file = @file
 
+    file = @recognizer.file
+    file.write("sheet_demo_grid3.png")
   end
 
   def test_should_return_the_recognizer_with_all_marks_flagged
@@ -98,4 +98,5 @@ class RubyMarks::RecognizerGridTest < Test::Unit::TestCase
     result.delete_if { |group, lines| lines.empty? }
     assert_equal expected_hash, result 
   end
+
 end

data/test/ruby_marks/recognizer_test.rb

@@ -1,7 +1,7 @@
 require "test_helper"
 
 class RubyMarks::RecognizerTest < Test::Unit::TestCase
-  
+=begin
   def setup 
     @file = 'assets/sheet_demo1.png'
     @recognizer = RubyMarks::Recognizer.new
@@ -42,7 +42,6 @@ class RubyMarks::RecognizerTest < Test::Unit::TestCase
 
   end
 
-=begin
   def test_should_initialize_a_recognizer_with_a_valid_file
     assert_equal @file, @recognizer.filename
   end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_marks
 version: !ruby/object:Gem::Version
-  version: 0.3.5
-  prerelease: 
+  version: 0.4.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,24 +34,26 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
-- lib/ruby_marks.rb
-- lib/ruby_marks/version.rb
-- lib/ruby_marks/support.rb
+- lib/ruby_marks/image_utils.rb
 - lib/ruby_marks/mark.rb
-- lib/ruby_marks/group.rb
 - lib/ruby_marks/watcher.rb
 - lib/ruby_marks/recognizer.rb
+- lib/ruby_marks/flood_scan.rb
+- lib/ruby_marks/group.rb
+- lib/ruby_marks/support.rb
 - lib/ruby_marks/config.rb
-- lib/ruby_marks/image_utils.rb
+- lib/ruby_marks/version.rb
+- lib/ruby_marks.rb
 - test/test_helper.rb
-- test/ruby_marks/recognizer_test.rb
-- test/ruby_marks/recognizer_grid_test.rb
 - test/ruby_marks/watcher_test.rb
 - test/ruby_marks/image_utils_test.rb
+- test/ruby_marks/recognizer_grid_test.rb
+- test/ruby_marks/recognizer_test.rb
 homepage: https://github.com/andrerpbts/ruby_marks.git
 licenses:
 - MIT
-post_install_message: ! "\n      *** NOTE: You are running the ImageMagick under 16bits
+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
   ***\n\n      We changed the way it recognizes the marks. It's not based on clocks
@@ -65,26 +64,24 @@ 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.25
+rubygems_version: 2.1.11
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A simple OMR tool
 test_files:
 - test/test_helper.rb
-- test/ruby_marks/recognizer_test.rb
-- test/ruby_marks/recognizer_grid_test.rb
 - test/ruby_marks/watcher_test.rb
 - test/ruby_marks/image_utils_test.rb
+- test/ruby_marks/recognizer_grid_test.rb
+- test/ruby_marks/recognizer_test.rb