imatcher 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7b023655f4f68f37b2d4a48c89dc11b367b2fa77
-  data.tar.gz: 542127918bee9dbc4a0b849f852f36eb138d6a8f
+  metadata.gz: c95e7ff691b3bd8a4c0225764cd6352e0b013cc3
+  data.tar.gz: 2ad7efe2e068f910d686d18b3f84ff35832354d2
 SHA512:
-  metadata.gz: 1bb1b4da86c334eaf59c7a33c5e95b85f1304b6af8859e5f6928af4c0dabdf4388cf8b8c1b7a2e79b1ab5e8ea7a2fb2661f74b1c4fd8e459ee44619ba1057207
-  data.tar.gz: 7ba78053279d58196c07a29700caf8f1fcdc3366780a997e53f7100bb36438a71e0e39995a2cb279dbd0ce1ef44abe151aed6ecc9f441bd40007c1dbeaf22381
+  metadata.gz: 14b97bfa6fc938c673aa126a56604bd51c1766b596e26302dd08416299219e058d8e294260f06c72099066e77df322ec393010541b2b57f3d46515eb96ece271
+  data.tar.gz: 0ccb28a3281c111a3a552f1a42c657113e868e8e2bc6cd6eab106ce281c1aba92a49f688ffa453b3d6fa141170839e9bf01758d570e3447f25bc15b62e30e689

data/README.md

@@ -88,6 +88,22 @@ res = Imatcher::Matcher.new(options).compare(path_1, path_2)
 
 ```
 
+## Excluding area
+
+<img src="https://raw.githubusercontent.com/teachbase/imatcher/master/spec/fixtures/a.png" width="300" />
+<img src="https://raw.githubusercontent.com/teachbase/imatcher/master/spec/fixtures/a1.png" width="300" />
+
+You can exclude area from comparing by passing `:exclude_area` to `compare`.
+E.g., if `path_1` and `path_2` contain images above
+```ruby
+Imatcher.compare(path_1, path_2, exclude_area: [200, 150, 275, 200]).match? # => true
+```
+`[200, 150, 275, 200]` is array of two vertices of rectangle -- (200, 150) is left-top vertex and (275, 200) is right-bottom.
+
+## Including area
+
+You can set bounds of comparing by passing `:include_area` to `compare` with array similar to previous example
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/teachbase/imatcher.

data/imatcher.gemspec

@@ -6,7 +6,6 @@ Gem::Specification.new do |spec|
   spec.version       = Imatcher::VERSION
   spec.authors       = ["palkan"]
   spec.email         = ["dementiev.vm@gmail.com"]
-
   spec.summary       = "Image comparison lib"
   spec.description   = "Image comparison lib built on top of ChunkyPNG"
   spec.homepage      = "http://github.com/teachbase/imatcher"

data/lib/imatcher/color_methods.rb

@@ -11,5 +11,17 @@ module Imatcher
     def brightness(a)
       0.3 * r(a) + 0.59 * g(a) + 0.11 * b(a)
     end
+
+    def red
+      rgb(255, 0, 0)
+    end
+
+    def green
+      rgb(0, 255, 0)
+    end
+
+    def blue
+      rgb(0, 0, 255)
+    end
   end
 end

data/lib/imatcher/image.rb

@@ -13,11 +13,13 @@ module Imatcher
       end
     end
 
-    def compare_each_pixel(image)
-      height.times do |y|
-        next if image.row(y) == row(y)
-        row(y).each_with_index do |pixel, x|
-          yield(pixel, image[x, y], x, y)
+    def compare_each_pixel(image, area: nil)
+      area = bounding_rect if area.nil?
+      (area.top..area.bot).each do |y|
+        range = (area.left..area.right)
+        next if image.row(y).slice(range) == row(y).slice(range)
+        (area.left..area.right).each do |x|
+          yield(self[x, y], image[x, y], x, y)
         end
       end
     end
@@ -40,12 +42,19 @@ module Imatcher
       [width, height] == [image.width, image.height]
     end
 
-    def render_bounds(left, bot, right, top)
-      rect(left, bot, right, top, rgb(255, 0, 0))
-    end
-
     def inspect
       "Image:#{object_id}<#{width}x#{height}>"
     end
+
+    def highlight_rectangle(rect, color = :red)
+      fail ArgumentError, "Undefined color: #{color}" unless respond_to?(color)
+      return self if rect.nil?
+      rect(*rect.bounds, send(color))
+      self
+    end
+
+    def bounding_rect
+      Rectangle.new(0, 0, width - 1, height - 1)
+    end
   end
 end

data/lib/imatcher/matcher.rb

@@ -15,17 +15,35 @@ module Imatcher
 
     def initialize(options = {})
       mode_type = options.delete(:mode) || :rgb
+      fail ArgumentError, "Undefined mode: #{ mode_type }" unless MODES.keys.include?(mode_type)
       @mode = Modes.const_get(MODES[mode_type]).new(options)
     end
 
     def compare(a, b)
       a = Image.from_file(a) unless a.is_a?(Image)
       b = Image.from_file(b) unless b.is_a?(Image)
-      raise SizesMismatchError,
-            "Size mismatch: first image size: " \
-            "#{a.width}x#{a.height}, " \
-            "second image size: " \
-            "#{b.width}x#{b.height}" unless a.sizes_match?(b)
+
+      fail SizesMismatchError,
+           "Size mismatch: first image size: " \
+           "#{a.width}x#{a.height}, " \
+           "second image size: " \
+           "#{b.width}x#{b.height}" unless a.sizes_match?(b)
+
+      image_area = Rectangle.new(0, 0, a.width - 1, a.height - 1)
+
+      unless mode.exclude_rect.nil?
+        fail ArgumentError,
+             "Bounds must be in image" unless image_area.contains?(mode.exclude_rect)
+      end
+
+      unless mode.include_rect.nil?
+        fail ArgumentError,
+             "Bounds must be in image" unless image_area.contains?(mode.include_rect)
+        unless mode.exclude_rect.nil?
+          fail ArgumentError,
+               "Included area must contain excluded" unless mode.include_rect.contains?(mode.exclude_rect)
+        end
+      end
 
       mode.compare(a, b)
     end

data/lib/imatcher/modes/base.rb

@@ -1,21 +1,26 @@
 module Imatcher
   module Modes
     class Base # :nodoc:
+      require 'imatcher/rectangle'
       include ColorMethods
 
-      attr_reader :result, :threshold, :bounds
+      attr_reader :result, :threshold, :bounds, :exclude_rect, :include_rect
 
-      def initialize(threshold: 0.0)
+      def initialize(threshold: 0.0, exclude_rect: nil, include_rect: nil)
+        @include_rect = Rectangle.new(*include_rect) unless include_rect.nil?
+        @exclude_rect = Rectangle.new(*exclude_rect) unless exclude_rect.nil?
         @threshold = threshold
         @result = Result.new(self, threshold)
       end
 
       def compare(a, b)
         result.image = a
-        @bounds = [0, 0, result.image.width - 1, result.image.height - 1]
+        @include_rect ||= a.bounding_rect
+        @bounds = Rectangle.new(*include_rect.bounds)
 
-        b.compare_each_pixel(a) do |b_pixel, a_pixel, x, y|
+        b.compare_each_pixel(a, area: include_rect) do |b_pixel, a_pixel, x, y|
           next if pixels_equal?(b_pixel, a_pixel)
+          next if !exclude_rect.nil? && exclude_rect.contains_point?(x, y)
           update_result(b_pixel, a_pixel, x, y)
         end
 
@@ -24,15 +29,17 @@ module Imatcher
       end
 
       def diff(bg, diff)
-        diff_image = background(bg)
+        diff_image = background(bg).highlight_rectangle(exclude_rect, :blue)
         diff.each do |pixels_pair|
           pixels_diff(diff_image, *pixels_pair)
         end
-        create_diff_image(bg, diff_image).render_bounds(*bounds)
+        create_diff_image(bg, diff_image).
+          highlight_rectangle(bounds).
+          highlight_rectangle(include_rect, :green)
       end
 
       def score
-        @result.diff.length.to_f / @result.image.pixels.length
+        result.diff.length.to_f / area
       end
 
       def update_result(*_args, x, y)
@@ -40,10 +47,16 @@ module Imatcher
       end
 
       def update_bounds(x, y)
-        bounds[0] = [x, bounds[0]].max
-        bounds[1] = [y, bounds[1]].max
-        bounds[2] = [x, bounds[2]].min
-        bounds[3] = [y, bounds[3]].min
+        bounds.left = [x, bounds.left].max
+        bounds.top = [y, bounds.top].max
+        bounds.right = [x, bounds.right].min
+        bounds.bot = [y, bounds.bot].min
+      end
+
+      def area
+        area = include_rect.area
+        return area if exclude_rect.nil?
+        area - exclude_rect.area
       end
     end
   end

data/lib/imatcher/modes/delta.rb

@@ -47,7 +47,7 @@ module Imatcher
       end
 
       def score
-        @delta_score / result.image.pixels.length
+        @delta_score / area
       end
     end
   end

data/lib/imatcher/modes/rgb.rb

@@ -18,7 +18,7 @@ module Imatcher
         Image.new(bg.width, bg.height, BLACK)
       end
 
-      def create_diff_image(bg, diff_image)
+      def create_diff_image(_bg, diff_image)
         diff_image
       end
 

data/lib/imatcher/rectangle.rb

@@ -0,0 +1,31 @@
+module Imatcher
+  class Rectangle
+    attr_accessor :left, :top, :right, :bot
+
+    def initialize(l, t, r, b)
+      @left = l
+      @top = t
+      @right = r
+      @bot = b
+    end
+
+    def area
+      (right - left + 1) * (bot - top + 1)
+    end
+
+    def contains?(rect)
+      (left <= rect.left) &&
+        (right >= rect.right) &&
+        (top <= rect.top) &&
+        (bot >= rect.bot)
+    end
+
+    def bounds
+      [left, top, right, bot]
+    end
+
+    def contains_point?(x, y)
+      x.between?(left, right) && y.between?(top, bot)
+    end
+  end
+end

data/lib/imatcher/version.rb

@@ -1,3 +1,3 @@
 module Imatcher # :nodoc:
-  VERSION = "0.1.3".freeze
+  VERSION = "0.1.4".freeze
 end

data/spec/image_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Imatcher::Image do
+  describe "highlight_rectangle" do
+    let(:image) { described_class.new(10, 10, described_class::BLACK) }
+    let(:rect) { Imatcher::Rectangle.new(0, 0, 1, 1) }
+    subject { image.highlight_rectangle(rect, :deep_purple) }
+
+    it { expect { subject }.to raise_error(ArgumentError) }
+  end
+end

data/spec/integrations/delta_spec.rb

@@ -18,13 +18,13 @@ describe Imatcher::Modes::Delta do
       context "below score" do
         let(:options) { { mode: :delta, threshold: 0.01 } }
 
-        it { expect(subject).to eq false }
+        it { expect(subject).to be_falsey }
       end
 
       context "above score" do
         let(:options) { { mode: :delta, threshold: 0.1 } }
 
-        it { expect(subject).to eq true }
+        it { expect(subject).to be_truthy }
       end
     end
   end

data/spec/integrations/rgb_spec.rb

@@ -23,4 +23,29 @@ describe Imatcher::Modes::RGB do
       expect(subject.difference_image).to eq(Imatcher::Image.from_file(image_path("rgb_diff")))
     end
   end
+
+  context "exclude rect" do
+    let(:options) { { exclude_rect: [200, 150, 275, 200] } }
+    let(:path_2) { image_path "a1" }
+    it { expect(subject.difference_image).to eq Imatcher::Image.from_file(image_path("exclude")) }
+    it { expect(subject.score).to eq 0 }
+
+    context "calculates score correctly" do
+      let(:path_2) { image_path "darker" }
+
+      it { expect(subject.score).to eq 1 }
+    end
+  end
+
+  context "include rect" do
+    let(:options) { { include_rect: [0, 0, 100, 100] } }
+    let(:path_2) { image_path "a1" }
+    it { expect(subject.difference_image).to eq Imatcher::Image.from_file(image_path("include")) }
+    it { expect(subject.score).to eq 0 }
+
+    context "calculates score correctly" do
+      let(:path_2) { image_path "darker" }
+      it { expect(subject.score).to eq 1 }
+    end
+  end
 end

data/spec/matcher_spec.rb

@@ -28,18 +28,50 @@ describe Imatcher::Matcher do
 
       it { expect(subject.mode).to be_a Imatcher::Modes::Delta }
     end
+
+    context "with undefined mode" do
+      let(:options) { { mode: :gamma } }
+
+      it { expect { subject }.to raise_error(ArgumentError) }
+    end
   end
 
   describe "compare" do
     let(:path_1) { image_path "very_small" }
     let(:path_2) { image_path "very_small" }
-    subject { Imatcher::Matcher.new.compare(path_1, path_2) }
+    let(:options) { {} }
+    subject { Imatcher.compare(path_1, path_2, options) }
 
     it { expect(subject).to be_a Imatcher::Result }
 
     context "when sizes mismatch" do
       let(:path_2) { image_path "small" }
-      it { expect { subject }.to raise_error(Imatcher::SizesMismatchError) }
+      it { expect { subject }.to raise_error Imatcher::SizesMismatchError }
+    end
+
+    context "with negative exclude rect bounds" do
+      let(:options) { { exclude_rect: [-1, -1, -1, -1] } }
+      it { expect { subject }.to raise_error ArgumentError }
+    end
+
+    context "with big exclude rect bounds" do
+      let(:options) { { exclude_rect: [100, 100, 100, 100] } }
+      it { expect { subject }.to raise_error ArgumentError }
+    end
+
+    context "with negative include rect bounds" do
+      let(:options) { { include_rect: [-1, -1, -1, -1] } }
+      it { expect { subject }.to raise_error ArgumentError }
+    end
+
+    context "with big include rect bounds" do
+      let(:options) { { include_rect: [100, 100, 100, 100] } }
+      it { expect { subject }.to raise_error ArgumentError }
+    end
+
+    context "with wrong include and exclude rects combination" do
+      let(:options) { { include_rect: [1, 1, 2, 2], exclude_rect: [0, 0, 1, 1] } }
+      it { expect { subject }.to raise_error ArgumentError }
     end
   end
 end

data/spec/rectangle_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Imatcher::Rectangle do
+  let(:rect) { described_class.new(0, 0, 9, 9) }
+
+  describe 'area' do
+    subject { rect.area }
+
+    it { expect(subject).to eq 100 }
+  end
+
+  describe "contains?" do
+    let(:rect2) { described_class.new(1, 1, 8, 8) }
+    subject { rect.contains?(rect2) }
+
+    it { expect(subject).to be_truthy }
+
+    context "when does not contain" do
+      let(:rect2) { described_class.new(2, 2, 10, 10) }
+
+      it { expect(subject).to be_falsey }
+    end
+  end
+
+  describe "contains_point?" do
+    let(:point) { [5, 5] }
+    subject { rect.contains_point?(*point) }
+
+    it { expect(subject).to be_truthy }
+
+    context "when does not contain" do
+      let(:point) { [10, 10] }
+
+      it { expect(subject).to be_falsey }
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: imatcher
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - palkan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-18 00:00:00.000000000 Z
+date: 2016-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oily_png
@@ -94,21 +94,27 @@ files:
 - lib/imatcher/modes/delta.rb
 - lib/imatcher/modes/grayscale.rb
 - lib/imatcher/modes/rgb.rb
+- lib/imatcher/rectangle.rb
 - lib/imatcher/result.rb
 - lib/imatcher/version.rb
 - spec/fixtures/a.png
+- spec/fixtures/a1.png
 - spec/fixtures/b.png
 - spec/fixtures/darker.png
 - spec/fixtures/delta_diff.png
+- spec/fixtures/exclude.png
 - spec/fixtures/grayscale_diff.png
+- spec/fixtures/include.png
 - spec/fixtures/rgb_diff.png
 - spec/fixtures/small.png
 - spec/fixtures/very_small.png
+- spec/image_spec.rb
 - spec/imatcher_spec.rb
 - spec/integrations/delta_spec.rb
 - spec/integrations/grayscale_spec.rb
 - spec/integrations/rgb_spec.rb
 - spec/matcher_spec.rb
+- spec/rectangle_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/teachbase/imatcher
 licenses:
@@ -135,3 +141,4 @@ signing_key:
 specification_version: 4
 summary: Image comparison lib
 test_files: []
+has_rdoc: