screenpress 0.2.1 → 0.3.0

data/lib/screenpress.rb

@@ -3,10 +3,14 @@ require "capybara"
 
 module Screenpress
   autoload :Config,    'screenpress/config'
-  autoload :Compare,   'screenpress/compare'
   autoload :DSL,       'screenpress/dsl'
   autoload :Saver,     'screenpress/saver'
 
+  module Compare
+    autoload :Bits,    'screenpress/compare/bits'
+    autoload :Phashion, 'screenpress/compare/phashion'
+  end
+
   class << self
     def config
       @config ||= Screenpress::Config.new

data/lib/screenpress/compare/bits.rb

@@ -0,0 +1,105 @@
+# based on: https://github.com/intridea/green_onion/blob/master/lib/green_onion/compare.rb
+
+require "oily_png"
+
+module Screenpress
+  module Compare
+    class Bits
+      include ChunkyPNG::Color
+
+      attr_reader :orig_image, :fresh_image
+      def initialize(orig_path, fresh_path)
+        @orig_image  = ChunkyPNG::Image.from_file(orig_path)
+        @fresh_image = ChunkyPNG::Image.from_file(fresh_path)
+        @diff_index  = []
+      end
+
+      def difference
+        diff_iterator
+        percentage_diff
+      end
+
+      def threshold
+        Screenpress.config.threshold || 0.1
+      end
+
+      protected
+
+      # Pulled from Jeff Kreeftmeijer's post here: http://jeffkreeftmeijer.com/2011/comparing-images-and-creating-image-diffs/
+      # Run through all of the pixels on both org image, and fresh image. Change the pixel color accordingly.
+      def update_diff_index(x, y, pixel)
+        lowest_score = 1
+
+        begin
+          return if pixel == fresh_image[x,y]
+        rescue ChunkyPNG::OutOfBounds
+            # off the edge!
+        end
+        
+        # try a bit in each direction to account for differences
+        [-2, -1, 0, 1, 2].each do |yd|
+          [-1, 0, 1].each do |xd|
+            begin
+              # to do based on more nuanced score
+              #score = Math.sqrt(
+              #        (r(fresh_image[x+xd,y+yd]) - r(pixel)) ** 2 +
+              #        (g(fresh_image[x+xd,y+yd]) - g(pixel)) ** 2 +
+              #        (b(fresh_image[x+xd,y+yd]) - b(pixel)) ** 2
+              #      ) / Math.sqrt(MAX ** 2 * 3)
+              
+              return if pixel == fresh_image[x+xd,y+yd]
+
+              score = 1
+
+              lowest_score = score if score < lowest_score
+            rescue ChunkyPNG::OutOfBounds
+              # off the edge!
+            end
+          end
+        end
+        
+        @diff_index << [x,y,lowest_score] if lowest_score > 0
+      end
+
+      def diff_iterator
+        orig_image.height.times do |y|
+          orig_image.row(y).each_with_index do |pixel, x|
+            update_diff_index(x, y, pixel)
+          end
+        end
+
+        return true
+      end
+
+      # Returns the numeric results of the diff of 2 images
+      def percentage_diff
+        return @percentage_changed if @percentage_changed
+        total_px = orig_image.pixels.length
+        changed_px = @diff_index.length
+
+        # to do based on more nuanced score
+        #changed_px = 0.0
+        #@diff_index.each do |x,y,score|
+          # could use the actual score
+        #  changed_px += score
+        #end
+        @percentage_changed = ((changed_px.to_f*100) / total_px)
+      end
+
+      # Saves the visual diff as a separate file
+      def save_visual_diff
+        x, y = @diff_index.map{ |xy| xy[0] }, @diff_index.map{ |xy| xy[1] }
+        diff_path = @orig_path.insert(-5, '_diff')
+
+        begin
+          fresh_image.rect(x.min, y.min, x.max, y.max, ChunkyPNG::Color.rgb(0,255,0))
+        rescue NoMethodError
+          puts "Both images are the same."
+        end
+        
+        fresh_image.save(diff_path)
+      end
+
+    end
+  end
+end

data/lib/screenpress/compare/phashion.rb

@@ -0,0 +1,23 @@
+require 'phashion'
+
+module Screenpress
+  module Compare
+    class Phashion
+      attr_reader :orig_image, :fresh_image, :difference
+      def initialize(orig_path, fresh_path)
+        @orig_image  = ::Phashion::Image.new(orig_path)
+        @fresh_image = ::Phashion::Image.new(fresh_path)
+      end
+
+      def difference
+        orig_print  = orig_image.fingerprint
+        fresh_print = fresh_image.fingerprint
+        ::Phashion.hamming_distance(orig_print, fresh_print)
+      end
+
+      def threshold
+        Screenpress.config.threshold || 15
+      end
+    end
+  end
+end

data/lib/screenpress/config.rb

@@ -39,7 +39,16 @@ module Screenpress
     end
 
     def threshold
-      @threshold ||= 0.1
+      @threshold
+    end
+
+    def comparator=val
+      @comparator = val
+    end
+
+    def comparator
+      @comparator ||= calc_comparator
+      @comparator
     end
 
     protected
@@ -53,6 +62,11 @@ module Screenpress
       true
     end
 
+    def calc_comparator
+      # TODO: see what's there
+      "bits"
+    end
+
     def calc_root_string
       return Rails.root.to_s                if defined?(Rails)
       return Padrino.root.to_s              if defined?(Padrino)

data/lib/screenpress/saver.rb

@@ -28,8 +28,7 @@ module Screenpress
       return false unless Screenpress::Saver::Proxy.save!(capybara.current_driver, page.driver, tmp_file)
 
       # is it different?
-      compare = Screenpress::Compare.new(filename, tmp_file, Screenpress.config.threshold)
-      if compare.same?
+      if same?(filename, tmp_file)
         File.delete(tmp_file)
       else
         FileUtils.mv(tmp_file, filename)
@@ -41,6 +40,49 @@ module Screenpress
       raise e
     end
 
+    def same?(filename, tmp_file)
+      return !File.exists?(tmp_file) if !File.exists?(filename)
+
+      compare = comparator.new(filename, tmp_file)
+      if compare.respond_to?(:difference)
+        difference = compare.difference
+        if compare.respond_to?(:threshold)
+          threshold = compare.threshold
+        else
+          threshold = Screenpress.config.threshold || 0
+        end
+        if difference > threshold
+          puts "   Screenpress #{filename} different: #{difference} > #{threshold}"
+          return false
+        else
+          puts "   Screenpress #{filename} same: #{difference} <= #{threshold}"
+          return true
+        end
+      else
+        if compare.same?
+          return true
+        else
+          puts "   Screenpress #{filename} different!"
+          return false
+        end
+      end
+    end
+
+    def comparator
+      case Screenpress.config.comparator
+      when "bits"
+        Screenpress::Compare::Bits
+      when "phashion", "phash"
+        Screenpress::Compare::Phashion
+      when "magick"
+        raise "ImageMagick comparator not yet implemented"
+      when "perceptualdiff"
+        raise "perceptualdiff comparator not yet implemented"
+      else
+        raise "Unknown comparator"
+      end
+    end
+
     def ensure_directory
       folder = File.dirname(filename)
       return if File.directory?(folder)

data/lib/screenpress/version.rb

@@ -1,3 +1,3 @@
 module Screenpress
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/screenpress.gemspec

@@ -21,6 +21,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency "capybara"
   spec.add_dependency "oily_png"
 
+  spec.add_runtime_dependency("phashion")
+
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: screenpress
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-09 00:00:00.000000000 Z
+date: 2014-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capybara
@@ -43,6 +43,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: phashion
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -123,7 +139,8 @@ files:
 - README.md
 - Rakefile
 - lib/screenpress.rb
-- lib/screenpress/compare.rb
+- lib/screenpress/compare/bits.rb
+- lib/screenpress/compare/phashion.rb
 - lib/screenpress/config.rb
 - lib/screenpress/dsl.rb
 - lib/screenpress/saver.rb

data/lib/screenpress/compare.rb

@@ -1,120 +0,0 @@
-# based on: https://github.com/intridea/green_onion/blob/master/lib/green_onion/compare.rb
-
-require "oily_png"
-
-module Screenpress
-  class Compare
-    include ChunkyPNG::Color
-
-    attr_reader :orig_image, :fresh_image, :threshold
-    def initialize(orig_path, fresh_path, threshold)
-      @orig_path  = orig_path
-      @fresh_path = fresh_path
-      @threshold ||= threshold
-    end
-
-    def same?
-      return !File.exists?(@fresh_path) if !File.exists?(@orig_path)
-      setup
-
-      return false unless diff_iterator
-
-      
-      if percentage_diff > 0
-        puts "Image Percentage Different #{@orig_path}: #{percentage_diff}"
-        if percentage_diff > self.threshold
-          puts "   Image different!"
-          return false
-        end
-      end
-
-      true
-    end
-
-    protected
-
-    def setup
-      return if @diff_index
-      @orig_image  = ChunkyPNG::Image.from_file(@orig_path)
-      @fresh_image = ChunkyPNG::Image.from_file(@fresh_path)
-      @diff_index = []
-    end
-
-
-    # Pulled from Jeff Kreeftmeijer's post here: http://jeffkreeftmeijer.com/2011/comparing-images-and-creating-image-diffs/
-    # Run through all of the pixels on both org image, and fresh image. Change the pixel color accordingly.
-    def update_diff_index(x, y, pixel)
-      lowest_score = 1
-
-      begin
-        return if pixel == fresh_image[x,y]
-      rescue ChunkyPNG::OutOfBounds
-          # off the edge!
-      end
-      
-      # try a bit in each direction to account for differences
-      [-2, -1, 0, 1, 2].each do |yd|
-        [-1, 0, 1].each do |xd|
-          begin
-            # to do based on more nuanced score
-            #score = Math.sqrt(
-            #        (r(fresh_image[x+xd,y+yd]) - r(pixel)) ** 2 +
-            #        (g(fresh_image[x+xd,y+yd]) - g(pixel)) ** 2 +
-            #        (b(fresh_image[x+xd,y+yd]) - b(pixel)) ** 2
-            #      ) / Math.sqrt(MAX ** 2 * 3)
-            
-            return if pixel == fresh_image[x+xd,y+yd]
-
-            score = 1
-
-            lowest_score = score if score < lowest_score
-          rescue ChunkyPNG::OutOfBounds
-            # off the edge!
-          end
-        end
-      end
-      
-      @diff_index << [x,y,lowest_score] if lowest_score > 0
-    end
-
-    def diff_iterator
-      orig_image.height.times do |y|
-        orig_image.row(y).each_with_index do |pixel, x|
-          update_diff_index(x, y, pixel)
-        end
-      end
-
-      return true
-    end
-
-    # Returns the numeric results of the diff of 2 images
-    def percentage_diff
-      return @percentage_changed if @percentage_changed
-      total_px = orig_image.pixels.length
-      changed_px = @diff_index.length
-
-      # to do based on more nuanced score
-      #changed_px = 0.0
-      #@diff_index.each do |x,y,score|
-        # could use the actual score
-      #  changed_px += score
-      #end
-      @percentage_changed = ((changed_px.to_f*100) / total_px)
-    end
-
-    # Saves the visual diff as a separate file
-    def save_visual_diff
-      x, y = @diff_index.map{ |xy| xy[0] }, @diff_index.map{ |xy| xy[1] }
-      diff_path = @orig_path.insert(-5, '_diff')
-
-      begin
-        fresh_image.rect(x.min, y.min, x.max, y.max, ChunkyPNG::Color.rgb(0,255,0))
-      rescue NoMethodError
-        puts "Both images are the same."
-      end
-      
-      fresh_image.save(diff_path)
-    end
-
-  end
-end