watir_visual_diff 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4b59144d0fc2d9d5c3267367ab8c212e10cc2a57
+  data.tar.gz: f8b9b36c9bef41891938a8084d71c1d6bd3e8ce8
+SHA512:
+  metadata.gz: 60d535c8e4e962fc48846c9b0212059bd2dc73a5eb7ae312ed6969a7f17bc4537a686360ffccbe47535c0fb5d733d13529f21c2c7c28768fecfad14e65d905cf
+  data.tar.gz: af3dc2a60f7db4226af17676620595f3b31d9b2f4c911b141fd2d94c4369484fa6e088784e40a782fe7ef7078449f5db1e8095f0f8f61f06ff728991eccfab6c

data/.gitignore

@@ -0,0 +1,36 @@
+# Numerous always-ignore extensions
+*.diff
+*.err
+*.orig
+*.log
+*.rej
+*.swo
+*.swp
+*.vi
+*~
+*.sass-cache
+*.iml
+.idea/
+
+# Sublime
+*.sublime-project
+*.sublime-workspace
+
+# OS or Editor folders
+.DS_Store
+.cache
+.project
+.settings
+.tmproj
+Thumbs.db
+*.gem
+
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,48 @@
+AllCops:
+  # Include gemspec and Rakefile
+  Include:
+    - 'lib/**/*.rb'
+    - 'lib/**/*.rake'
+    - 'spec/**/*.rb'
+  Exclude:
+    - 'bin/**/*'
+    - 'spec/dummy/**/*'
+  Rails:
+    Enabled: false
+  DisplayCopNames: true
+  StyleGuideCopsOnly: false
+
+Style/AccessorMethodName:
+  Enabled: false
+
+Style/TrivialAccessors:
+  Enabled: false
+
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Style/StringLiterals: 
+  Enabled: false
+
+Style/SpaceInsideStringInterpolation:
+  EnforcedStyle: no_space
+
+Style/BlockDelimiters:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Style/ParallelAssignment:
+  Enabled: false
+
+Lint/AmbiguousRegexpLiteral:
+  Enabled: false
+
+Metrics/MethodLength:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Metrics/LineLength:
+  max: 100
+  Exclude:
+    - 'spec/**/*.rb'

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+cache: bundler
+rvm:
+  - 2.2
+  - ruby-head
+  - jruby-head
+
+notifications:
+  email: false
+
+before_install:
+  - gem install bundler
+
+script: bundle exec rake

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gem "rake", "~> 10.0"
+gem "rspec", "~> 3.0"
+gem "oily_png", "~> 1.2.1"
+local_gemfile = 'Gemfile.local'
+
+if File.exist?(local_gemfile)
+  eval(File.read(local_gemfile)) # rubocop:disable Lint/Eval
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Justin Commu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,116 @@
+[![Gem Version](https://badge.fury.io/rb/watir_visual_diff.svg)](https://rubygems.org/gems/watir_visual_diff) [![Build Status](https://travis-ci.org/teachbase/watir_visual_diff.svg?branch=master)](https://travis-ci.org/teachbase/watir_visual_diff)
+
+# WatirVisualDiff
+
+Compare PNG images in pure Ruby (uses [ChunkyPNG](https://github.com/wvanbergen/chunky_png)) using different algorithms.
+This is an utility library for image regression testing.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'watir_visual_diff'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install watir_visual_diff
+
+Additionally, you may want to install [oily_png](https://github.com/wvanbergen/oily_png) to improve performance when using MRI. Just install it globally or add to your Gemfile.
+
+## Modes
+
+WatirVisualDiff supports different ways (_modes_) of comparing images.
+
+Source images used in examples:
+
+<img src="https://raw.githubusercontent.com/teachbase/watir_visual_diff/master/spec/fixtures/a.png" width="300" />
+<img src="https://raw.githubusercontent.com/teachbase/watir_visual_diff/master/spec/fixtures/b.png" width="300" />
+
+### Base (RGB) mode
+
+Compare pixels by values, resulting score is a ratio of unequal pixels.
+Resulting diff represents per-channel difference.
+
+<img src="https://raw.githubusercontent.com/teachbase/watir_visual_diff/master/spec/fixtures/rgb_diff.png" width="300" />
+
+### Grayscale mode
+
+Compare pixels as grayscale (by brightness and alpha), resulting score is a ratio of unequal pixels (with respect to provided tolerance).
+
+Resulting diff contains grayscale version of the first image with different pixels highlighted in red and red bounding box.
+
+<img src="https://raw.githubusercontent.com/teachbase/watir_visual_diff/master/spec/fixtures/grayscale_diff.png" width="300" />
+
+### Delta
+
+Compare pixels using [Delta E](https://en.wikipedia.org/wiki/Color_difference) distance.
+Resulting diff contains grayscale version of the first image with different pixels highlighted in red (with respect to diff score).
+
+<img src="https://raw.githubusercontent.com/teachbase/watir_visual_diff/master/spec/fixtures/delta_diff.png" width="300" />
+
+## Usage
+
+```ruby
+# create new matcher with default threshold equals to 0
+# and base (RGB) mode
+cmp = WatirVisualDiff::Matcher.new
+cmp.mode #=> WatirVisualDiff::Modes::RGB
+
+# create matcher with specific threshold
+cmp = WatirVisualDiff::Matcher.new threshold: 0.05
+cmp.threshold #=> 0.05
+
+# create zero-tolerance grayscale matcher 
+cmp = WatirVisualDiff::Matcher.new mode: :grayscale, tolerance: 0
+cmp.mode #=> WatirVisualDiff::Modes::Grayscale
+
+res = cmp.compare(path_1, path_2)
+res #=> WatirVisualDiff::Result
+
+res.match? #=> true
+
+res.score #=> 0.0
+
+# Return diff image object
+res.difference_image #=> WatirVisualDiff::Image
+
+res.difference_image.save(new_path)
+
+# without explicit matcher
+res = WatirVisualDiff.compare(path_1, path_2, options) 
+
+# equals to
+res = WatirVisualDiff::Matcher.new(options).compare(path_1, path_2)
+
+```
+
+## Excluding rectangle
+
+<img src="https://raw.githubusercontent.com/teachbase/watir_visual_diff/master/spec/fixtures/a.png" width="300" />
+<img src="https://raw.githubusercontent.com/teachbase/watir_visual_diff/master/spec/fixtures/a1.png" width="300" />
+
+You can exclude rectangle from comparing by passing `:exclude_rect` to `compare`.
+E.g., if `path_1` and `path_2` contain images above
+```ruby
+WatirVisualDiff.compare(path_1, path_2, exclude_rect: [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 rectangle
+
+You can set bounds of comparing by passing `:include_rect` to `compare` with array similar to previous example
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/teachbase/watir_visual_diff.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+task :console do
+  sh 'pry -r ./lib/watir_visual_diff.rb'
+end

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "watir_visual_diff"
+
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/examples/performance.rb

@@ -0,0 +1,42 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'benchmark/ips'
+require 'watir_visual_diff'
+
+a = WatirVisualDiff::Image.from_file(File.expand_path('../../spec/fixtures/a.png', __FILE__))
+b = WatirVisualDiff::Image.from_file(File.expand_path('../../spec/fixtures/a.png', __FILE__))
+
+rgb = WatirVisualDiff::Matcher.new
+grayscale = WatirVisualDiff::Matcher.new mode: :grayscale
+delta = WatirVisualDiff::Matcher.new mode: :delta
+
+Benchmark.ips do |x|
+  x.report 'RGB' do
+    rgb.compare(a, b)
+  end
+
+  x.report 'Grayscale' do
+    grayscale.compare(a, b)
+  end
+
+  x.report 'Delta E' do
+    delta.compare(a, b)
+  end
+
+  x.compare!
+end
+
+Benchmark.ips do |x|
+  x.report 'RGB' do
+    rgb.compare(a, b).difference_image
+  end
+
+  x.report 'Grayscale' do
+    grayscale.compare(a, b).difference_image
+  end
+
+  x.report 'Delta E' do
+    delta.compare(a, b).difference_image
+  end
+
+  x.compare!
+end

data/lib/watir_visual_diff/color_methods.rb

@@ -0,0 +1,23 @@
+require "oily_png"
+
+module WatirVisualDiff
+  module ColorMethods # :nodoc:
+    include ChunkyPNG::Color
+
+    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/watir_visual_diff/image.rb

@@ -0,0 +1,60 @@
+require 'watir_visual_diff/color_methods'
+
+module WatirVisualDiff
+  # Extend ChunkyPNG::Image with some methods.
+  class Image < ChunkyPNG::Image
+    include ColorMethods
+
+    def each_pixel
+      height.times do |y|
+        row(y).each_with_index do |pixel, x|
+          yield(pixel, x, y)
+        end
+      end
+    end
+
+    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
+
+    def to_grayscale
+      each_pixel do |pixel, x, y|
+        self[x, y] = grayscale(brightness(pixel).round)
+      end
+      self
+    end
+
+    def with_alpha(value)
+      each_pixel do |pixel, x, y|
+        self[x, y] = rgba(r(pixel), g(pixel), b(pixel), value)
+      end
+      self
+    end
+
+    def sizes_match?(image)
+      [width, height] == [image.width, image.height]
+    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/watir_visual_diff/matcher.rb

@@ -0,0 +1,51 @@
+module WatirVisualDiff
+  # Matcher contains information about compare mode
+  class Matcher
+    require 'watir_visual_diff/image'
+    require 'watir_visual_diff/result'
+    require 'watir_visual_diff/modes'
+
+    MODES = {
+      rgb: 'RGB',
+      delta: 'Delta',
+      grayscale: 'Grayscale'
+    }.freeze
+
+    attr_reader :threshold, :mode
+
+    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)
+
+      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
+  end
+end

data/lib/watir_visual_diff/modes/base.rb

@@ -0,0 +1,63 @@
+module WatirVisualDiff
+  module Modes
+    class Base # :nodoc:
+      require 'watir_visual_diff/rectangle'
+      include ColorMethods
+
+      attr_reader :result, :threshold, :bounds, :exclude_rect, :include_rect
+
+      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
+        @include_rect ||= a.bounding_rect
+        @bounds = Rectangle.new(*include_rect.bounds)
+
+        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
+
+        result.score = score
+        result
+      end
+
+      def diff(bg, diff)
+        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).
+          highlight_rectangle(bounds).
+          highlight_rectangle(include_rect, :green)
+      end
+
+      def score
+        result.diff.length.to_f / area
+      end
+
+      def update_result(*_args, x, y)
+        update_bounds(x, y)
+      end
+
+      def update_bounds(x, y)
+        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
+end

data/lib/watir_visual_diff/modes/delta.rb

@@ -0,0 +1,54 @@
+module WatirVisualDiff
+  module Modes # :nodoc:
+    require 'watir_visual_diff/modes/base'
+
+    # Compare pixels using Delta E distance.
+    class Delta < Base
+      attr_reader :tolerance
+
+      def initialize(options)
+        @tolerance = options.delete(:tolerance) || 0.01
+        @delta_score = 0.0
+        super(options)
+      end
+
+      private
+
+      def pixels_equal?(a, b)
+        a == b
+      end
+
+      def update_result(a, b, x, y)
+        d = euclid(a, b) / (MAX * Math.sqrt(3))
+        return if d <= tolerance
+        @result.diff << [a, b, x, y, d]
+        @delta_score += d
+        super
+      end
+
+      def background(bg)
+        Image.new(bg.width, bg.height, WHITE).with_alpha(0)
+      end
+
+      def euclid(a, b)
+        Math.sqrt(
+          (r(a) - r(b))**2 +
+          (g(a) - g(b))**2 +
+          (b(a) - b(b))**2
+        )
+      end
+
+      def create_diff_image(bg, diff_image)
+        bg.to_grayscale.compose!(diff_image, 0, 0)
+      end
+
+      def pixels_diff(d, *_args, x, y, a)
+        d[x, y] = rgba(MAX, 0, 0, (a * MAX).round)
+      end
+
+      def score
+        @delta_score / area
+      end
+    end
+  end
+end

data/lib/watir_visual_diff/modes/grayscale.rb

@@ -0,0 +1,49 @@
+module WatirVisualDiff
+  module Modes # :nodoc:
+    require 'watir_visual_diff/modes/base'
+
+    # Compare pixels by alpha and brightness.
+    #
+    # Options:
+    # - tolerance - defines the maximum allowed difference for alpha/brightness
+    # (default value is 16)
+    class Grayscale < Base
+      DEFAULT_TOLERANCE = 16
+
+      attr_reader :tolerance
+
+      def initialize(options)
+        @tolerance = options.delete(:tolerance) || DEFAULT_TOLERANCE
+        super(options)
+      end
+
+      def pixels_equal?(a, b)
+        alpha = color_similar?(a(a), a(b))
+        brightness = color_similar?(brightness(a), brightness(b))
+        brightness && alpha
+      end
+
+      def update_result(a, b, x, y)
+        super
+        @result.diff << [a, b, x, y]
+      end
+
+      def background(bg)
+        bg.to_grayscale
+      end
+
+      def pixels_diff(d, _a, _b, x, y)
+        d[x, y] = rgb(255, 0, 0)
+      end
+
+      def create_diff_image(_bg, diff_image)
+        diff_image
+      end
+
+      def color_similar?(a, b)
+        d = (a - b).abs
+        d <= tolerance
+      end
+    end
+  end
+end

data/lib/watir_visual_diff/modes/rgb.rb

@@ -0,0 +1,34 @@
+module WatirVisualDiff
+  module Modes # :nodoc:
+    require 'watir_visual_diff/modes/base'
+
+    # Compare pixels by values.
+    # Resulting image contains per-channel differences.
+    class RGB < Base
+      def pixels_equal?(a, b)
+        a == b
+      end
+
+      def update_result(a, b, x, y)
+        super
+        @result.diff << [a, b, x, y]
+      end
+
+      def background(bg)
+        Image.new(bg.width, bg.height, BLACK)
+      end
+
+      def create_diff_image(_bg, diff_image)
+        diff_image
+      end
+
+      def pixels_diff(d, a, b, x, y)
+        d[x, y] = rgb(
+          (r(a) - r(b)).abs,
+          (g(a) - g(b)).abs,
+          (b(a) - b(b)).abs
+        )
+      end
+    end
+  end
+end

data/lib/watir_visual_diff/modes.rb

@@ -0,0 +1,7 @@
+module WatirVisualDiff
+  module Modes # :nodoc:
+    require 'watir_visual_diff/modes/rgb'
+    require 'watir_visual_diff/modes/grayscale'
+    require 'watir_visual_diff/modes/delta'
+  end
+end

data/lib/watir_visual_diff/rectangle.rb

@@ -0,0 +1,31 @@
+module WatirVisualDiff
+  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/watir_visual_diff/result.rb

@@ -0,0 +1,23 @@
+module WatirVisualDiff
+  # Object containing comparison score and diff image
+  class Result
+    attr_accessor :score, :image
+    attr_reader :diff, :mode, :threshold
+
+    def initialize(mode, threshold)
+      @score = 0.0
+      @diff = []
+      @threshold = threshold
+      @mode = mode
+    end
+
+    def difference_image
+      @diff_image ||= mode.diff(image, diff)
+    end
+
+    # Returns true iff score less or equals to threshold
+    def match?
+      score <= threshold
+    end
+  end
+end

data/lib/watir_visual_diff/version.rb

@@ -0,0 +1,3 @@
+module WatirVisualDiff # :nodoc:
+  VERSION = "0.0.1".freeze
+end

data/lib/watir_visual_diff.rb

@@ -0,0 +1,14 @@
+require "watir_visual_diff/version"
+
+# Compare PNG images using different algorithms
+module WatirVisualDiff
+  class SizesMismatchError < StandardError
+  end
+
+  require 'watir_visual_diff/matcher'
+  require 'watir_visual_diff/color_methods'
+
+  def self.compare(path_a, path_b, options = {})
+    Matcher.new(options).compare(path_a, path_b)
+  end
+end

data/spec/image_spec.rb

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

data/spec/imatcher_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe WatirVisualDiff do
+  it 'has a version number' do
+    expect(WatirVisualDiff::VERSION).not_to be nil
+  end
+end

data/spec/integrations/delta_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe WatirVisualDiff::Modes::Delta do
+  let(:path_1) { image_path "a" }
+  let(:path_2) { image_path "darker" }
+  subject { WatirVisualDiff.compare(path_1, path_2, options) }
+
+  let(:options) { { mode: :delta } }
+
+  context "with darker image" do
+    it "score around 0.075" do
+      expect(subject.score).to be_within(0.005).of(0.075)
+    end
+
+    context "with custom threshold" do
+      subject { WatirVisualDiff.compare(path_1, path_2, options).match? }
+
+      context "below score" do
+        let(:options) { { mode: :delta, threshold: 0.01 } }
+
+        it { expect(subject).to be_falsey }
+      end
+
+      context "above score" do
+        let(:options) { { mode: :delta, threshold: 0.1 } }
+
+        it { expect(subject).to be_truthy }
+      end
+    end
+  end
+
+  context "with different images" do
+    let(:path_2) { image_path "b" }
+
+    it "score around 0.0046" do
+      expect(subject.score).to be_within(0.0001).of(0.0046)
+    end
+
+    it "creates correct difference image" do
+      expect(subject.difference_image).to eq(WatirVisualDiff::Image.from_file(image_path("delta_diff")))
+    end
+
+    context "with high tolerance" do
+      let(:options) { { mode: :delta, tolerance: 0.1 } }
+
+      it "score around 0.0038" do
+        expect(subject.score).to be_within(0.0001).of(0.0038)
+      end
+    end
+  end
+end

data/spec/integrations/grayscale_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe WatirVisualDiff::Modes::Grayscale do
+  let(:path_1) { image_path "a" }
+  let(:path_2) { image_path "darker" }
+  subject { WatirVisualDiff.compare(path_1, path_2, options) }
+
+  let(:options) { { mode: :grayscale } }
+
+  context "darker image" do
+    it "score around 0.95" do
+      expect(subject.score).to be_within(0.05).of(0.95)
+    end
+  end
+
+  context "different images" do
+    let(:path_2) { image_path "b" }
+
+    it "score around 0.005" do
+      expect(subject.score).to be_within(0.001).of(0.005)
+    end
+
+    it "creates correct difference image" do
+      expect(subject.difference_image).to eq(WatirVisualDiff::Image.from_file(image_path("grayscale_diff")))
+    end
+  end
+
+  context "with zero tolerance" do
+    let(:options) { { mode: :grayscale, tolerance: 0 } }
+
+    context "darker image" do
+      it "score equals to 1" do
+        expect(subject.score).to eq 1.0
+      end
+    end
+
+    context "different image" do
+      let(:path_2) { image_path "b" }
+
+      it "score around 0.016" do
+        expect(subject.score).to be_within(0.001).of(0.016)
+      end
+    end
+
+    context "equal image" do
+      let(:path_2) { image_path "a" }
+
+      it "score equals to 0" do
+        expect(subject.score).to eq 0
+      end
+    end
+  end
+
+  context "with small tolerance" do
+    let(:options) { { mode: :grayscale, tolerance: 8 } }
+
+    context "darker image" do
+      it "score around 0.96" do
+        expect(subject.score).to be_within(0.005).of(0.96)
+      end
+    end
+
+    context "different image" do
+      let(:path_2) { image_path "b" }
+
+      it "score around 0.006" do
+        expect(subject.score).to be_within(0.0005).of(0.006)
+      end
+    end
+  end
+end

data/spec/integrations/rgb_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe WatirVisualDiff::Modes::RGB do
+  let(:path_1) { image_path "a" }
+  let(:path_2) { image_path "darker" }
+  subject { WatirVisualDiff.compare(path_1, path_2, options) }
+  let(:options) { {} }
+
+  context "with darker" do
+    it "score equals to 1" do
+      expect(subject.score).to eq 1
+    end
+  end
+
+  context "with different images" do
+    let(:path_2) { image_path "b" }
+
+    it "score around 0.016" do
+      expect(subject.score).to be_within(0.001).of(0.016)
+    end
+
+    it "creates correct difference image" do
+      expect(subject.difference_image).to eq(WatirVisualDiff::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 WatirVisualDiff::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 WatirVisualDiff::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

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe WatirVisualDiff::Matcher do
+  describe "new" do
+    subject { WatirVisualDiff::Matcher.new(options) }
+
+    context "without options" do
+      let(:options) { {} }
+
+      it { expect(subject.mode.threshold).to eq 0 }
+      it { expect(subject.mode).to be_a WatirVisualDiff::Modes::RGB }
+    end
+
+    context "with custom threshold" do
+      let(:options) { { threshold: 0.1 } }
+
+      it { expect(subject.mode.threshold).to eq 0.1 }
+    end
+
+    context "with custom options" do
+      let(:options) { { mode: :grayscale, tolerance: 0 } }
+
+      it { expect(subject.mode.tolerance).to eq 0 }
+    end
+
+    context "with custom mode" do
+      let(:options) { { mode: :delta } }
+
+      it { expect(subject.mode).to be_a WatirVisualDiff::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" }
+    let(:options) { {} }
+    subject { WatirVisualDiff.compare(path_1, path_2, options) }
+
+    it { expect(subject).to be_a WatirVisualDiff::Result }
+
+    context "when sizes mismatch" do
+      let(:path_2) { image_path "small" }
+      it { expect { subject }.to raise_error WatirVisualDiff::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 WatirVisualDiff::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

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rspec'
+require 'watir_visual_diff'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end
+
+def image_path(name)
+  "#{File.dirname(__FILE__)}/fixtures/#{name}.png"
+end

data/watir_visual_diff.gemspec

@@ -0,0 +1,21 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'watir_visual_diff/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "watir_visual_diff"
+  spec.version       = WatirVisualDiff::VERSION
+  spec.authors       = ["Justin Commu"]
+  spec.email         = ["jcommu@gmail.com"]
+  spec.summary       = "Image comparison library for Watir"
+  spec.description   = "Image comparison libray for Watir built on top of OilyPNG"
+  spec.homepage      = "https://github.com/automation-wizards/watir_visual_diff"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "oily_png", "~> 1.2.1"
+
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: watir_visual_diff
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Justin Commu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oily_png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Image comparison libray for Watir built on top of OilyPNG
+email:
+- jcommu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/performance.rb
+- lib/watir_visual_diff.rb
+- lib/watir_visual_diff/color_methods.rb
+- lib/watir_visual_diff/image.rb
+- lib/watir_visual_diff/matcher.rb
+- lib/watir_visual_diff/modes.rb
+- lib/watir_visual_diff/modes/base.rb
+- lib/watir_visual_diff/modes/delta.rb
+- lib/watir_visual_diff/modes/grayscale.rb
+- lib/watir_visual_diff/modes/rgb.rb
+- lib/watir_visual_diff/rectangle.rb
+- lib/watir_visual_diff/result.rb
+- lib/watir_visual_diff/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
+- watir_visual_diff.gemspec
+homepage: https://github.com/automation-wizards/watir_visual_diff
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.7
+signing_key: 
+specification_version: 4
+summary: Image comparison library for Watir
+test_files: []