dhashy 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a7567e25bfc6a4c3d15f84367691faaa0fc83e8b
-  data.tar.gz: 9924c009112370528804d1f257e2669347782aee
+SHA256:
+  metadata.gz: 6fa31671461b8254fadbaf8c8cf8f8e6aee66236781a2981e9b72295b3a3cf7b
+  data.tar.gz: 867ed25bb583d62cc4ef510b659fe9f51029cba9f430fdab0bf8c66062181dd1
 SHA512:
-  metadata.gz: 3fb31453a4d3f3c38ca182f23d72fd4a6f2f33a4d941489eb7358c8e3de63138ba26ef754e3d795bfc95c1c0e1354b97c73c1f6f013cc5109abd02cdc2ad89ff
-  data.tar.gz: 1f09b1d33ff31ec8c534dc9ab06ccb22082f51fd66ef38a2ecaefb33c9dae2fa0f033b4ef2fa2e3ffd0ef45a191990f7c02d84df9043418150465e9d37089cdd
+  metadata.gz: 9a4af5da1043c7c8ef48afc9bc4d5c0a2a9017904cde5aab2de3781f93c6a74dbf1c09a44c613c26236fb6de88b48d4bba26df251641ff7be70c046fbb14d160
+  data.tar.gz: fd6773e276b41aadd428429c827c0f99c49434440477ff557af055a219a9cf7409ce8ec47d4754e9d643d3c959d2dd9bc8cf945760d192bab0647f2e7592105e

data/.gitignore

@@ -6,4 +6,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+Gemfile
 Gemfile.lock

data/README.md

@@ -1,5 +1,13 @@
 # Dhashy
 
+Dhashy is a ruby gem implementing the *difference hash* algorithm for perceptual image matching.
+
+## Dependencies
+
+Dhashy is tested with ```imagemagick```, version 7. ```Graphicsmagick``` may or may not work.
+
+You can choose between ```mini_magick``` or ```vips``` for image processing, via the [```image_processing```](https://github.com/janko-m/image_processing) gem. When using ```vips```.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -19,7 +27,7 @@ Or install it yourself as:
 ## Usage
 
     first_image = MiniMagick::Image.open("test/test.jpg")
-    other_image = MiniMagick::Image.open("test/test.jpg")
+    other_image = MiniMagick::Image.open("test/8x8.jpg")
     first_hash = Dhashy.new(first_image)
 
     other_hash = Dhashy.new(other_image)

data/Rakefile

@@ -1,20 +1,39 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
-
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
-task :trials do
+task :tree do |t|
+   require '../minimagick/lib/mini_magick'
+   require './lib/dhashy'
+
+   results = []
+   (0..9).each do |folder|
+      ff = "../chill/data/images/004/%03i/???/1.jpg" % folder
+      puts ff
+      Pathname.glob(ff).combination(2).to_a.shuffle.each do |first, second|
+         puts "#{first} #{second}"
+         f1 = Dhashy.new(first)
+         f2 = Dhashy.new(second)
+         diff = f1 - f2
+         results << diff
+         puts "difference %2i avg %2i" % [diff, results.sum / results.size]
+      end
+   end
+end
+
+task :trials do |t|
 
    require "mini_magick"
+   require './lib/dhashy'
    parameters = {}
    parameters[:resize] = (0..9).map {|x| 100 - x * 10}
    parameters[:stretch] = ["100%", "10%", "25%", "50%", "75%", "133%", "200%", "400%", "1000%"]
    # parameters[:resize_y] = (1..10).map {|x| x * 10}
-   parameters[:crop] =  [false, "90%x90%+5%+5%", "50%x50%+25%+25%","90%x10%-1-1", "10%x100%-10%-10%"]
+   #parameters[:crop] =  [false, "90%x90%+5%+5%", "50%x50%+25%+25%","90%x10%-1-1", "10%x100%-10%-10%"]
    parameters[:rotate] = (0..7).map {|x| x * 45}
    parameters[:flip] = [false, true]
    parameters[:monochrome] = [false, true]
@@ -24,41 +43,47 @@ task :trials do
    parameters.each do |key, values|
       results[key] = Hash[values.map {|value| [value.to_s, []]}]
    end
-
-   original = Dhashy.new(MiniMagick::Image.open("test/test.jpg"))
+   original = Dhashy.new(MiniMagick::Image.open("test/test.jpg"), 128)
 
    parameters.each do |change, choices|
       choices.each do |choice|
 
-      settings = Hash[parameters.map {|parameter, values| [parameter, values.first]}]
-      settings[change] = choice
-      # settings = Hash[parameters.map {|parameter, values| [parameter, values.sample]}]
-      other = MiniMagick::Image.open("test/test.jpg")
-      t = other.get_pixels.size
-      other.combine_options do |image|
-         image.resize "#{settings[:resize]}%x#{settings[:stretch]}!"
-         image.rotate settings[:rotate]
-         image.flip if settings[:flip]
-         image.crop settings[:crop] if settings[:crop]
-         settings[:contrast].times { image.contrast } if settings[:contrast]
-         image.enhance if settings[:enhance]
-         image.monochrome if settings[:monochrome]
-      end
-      u = other.get_pixels.size
-      puts "#{t} #{u} #{settings[:resize]}"
-      diff = original - Dhashy.new(other)
-      parameters.each do |key, values|
-         results[key][settings[key].to_s] << diff if key == change
+         settings = Hash[parameters.map {|parameter, values| [parameter, values.first]}]
+         settings[change] = choice
+         other = MiniMagick::Image.open("test/test.jpg")
+         t = other.get_pixels.size
+         other.combine_options do |image|
+            image.resize "#{settings[:resize]}%x#{settings[:stretch]}!"
+            image.rotate settings[:rotate]
+            image.flip if settings[:flip]
+            image.crop settings[:crop] if settings[:crop]
+            settings[:contrast].times { image.contrast } if settings[:contrast]
+            image.enhance if settings[:enhance]
+            image.monochrome if settings[:monochrome]
+         end
+
+         u = other.get_pixels.size
+         otherhash = Dhashy.new(other)
+         puts "original"
+         puts original.display
+         puts "other"
+         puts otherhash.display
+         diff = original - otherhash
+         puts "diff: #{diff}"
+         parameters.each do |key, values|
+            results[key][settings[key].to_s] << diff if key == change
+         end
       end
    end
-   end
-   puts results
+
    results.each do |modification, options|
+      puts modification
       options.keys.sort.each do |option|
-         results = options[option]
-         next unless results.size > 0
-         puts "   %2i %4i %s" % [results.sum / results.size, results.size, option]
+         thisresult = options[option]
+         next unless thisresult.size > 0
+         puts "   %2i %4i %s" % [thisresult.sum / thisresult.size, thisresult.size, option]
       end
    end
 end
+
 task :default => :test

data/dhashy.gemspec

@@ -19,8 +19,8 @@ Gem::Specification.new do |spec|
   end
 
   spec.require_paths = ["lib"]
-  spec.add_dependency "mini_magick", "~> 4.0"
-  spec.add_development_dependency "bundler", "~> 1.16.a"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency "mini_magick", "~> 4"
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 12.3"
   spec.add_development_dependency "minitest", "~> 5.0"
 end

data/lib/dhashy/version.rb

@@ -1,3 +1,3 @@
 class Dhashy
-  VERSION = "1.0.0"
+  VERSION = "1.0.2"
 end

data/lib/dhashy.rb

@@ -1,38 +1,130 @@
 require "dhashy/version"
 
+# @author Matthias Winkelmann <m@matthi.coffee>
+# The *difference hash* is a compact representation
+# of an image (i. e. photo) that works well for fuzzy
+# finding of pairs of images that are substantially
+# euqal.
+#
+
 class Dhashy
-   def initialize(jpg)
-      return from_array(jpg) if jpg.class == Array
+   attr_reader :size
+
+   def initialize(jpg, size=128)
+      self.size = size
+
+      return from_array(jpg) if jpg.is_a? Array
+      jpg = MiniMagick::Image.open(jpg.to_s) if jpg.is_a? Pathname
       jpg.combine_options do |j|
-         j.channel_fx "Gray"
-         j.resize "9x8!"
+         j.resize "#{@dimension + 1}x#{@dimension + 1}!"
+      end
+      @pixels = jpg.get_pixels.map {|row| row.map {|p| ((p[0].to_f * 299) + (p[1] * 587) + (p[2] * 114)).to_f / 1000.0  }}
+      @h = from_array(@pixels)
+   end
+
+   # Our budget is spent on two square matrices:
+   #   one with the differences from row to row
+   #   the second with differences from column to column
+
+   def dimension(size)
+      Math.sqrt(size / 2).to_i
+   end
+
+   def size=(newsize)
+      fail(ArgumentError, "size must be integer, got %s: %s" % [newsize, newsize.class]) unless newsize.is_a?(Numeric) 
+      fail(ArgumentError, "size must be integer, got %s: %s" % [newsize, newsize.class]) unless newsize.integer?
+      fail(ArgumentError, "size must be >= 4") unless newsize >= 4 
+      if self.dimension(newsize) !=  Math.sqrt(newsize / 2.0)
+        fail(ArgumentError, "sqrt(size / 2) must be integer, is sqrt(%s / 2) / 2 = %s" % [newsize, self.dimension(newsize)]) 
       end
-      @hash = from_array(jpg.get_pixels.map {|x| x.map(&:first) })
+      @size = newsize
+      @dimension = self.dimension(@size)
    end
+
+   # (Hamming-) Distance, or visual difference
+   #
+   # @param [DHashy] another hash
+   # @return [Integer] The Hamming distance (also Manhattan-distance),
+   #    i. e. the number of different bits
+
    def -(other)
-      (0..7).map {|x| (0..7).map {|y| (@hash[x][y] - other[x][y]).abs}.sum}.sum
+      [0,1].map { |matrix| (0...@dimension).map {|x| (0...@dimension).map {|y| (@h[matrix][x][y] == other[matrix][x][y]) ? 0 : 1 }.sum}.sum}.sum
    end
+
    def[](index)
-      @hash[index]
+      @h[index]
    end
-   def ==(other)
+
+   # Visual Equality
+   #
+   # @oaram [DHashy] another hash
+   # @param [cutoff] number of bits allowed to differ.
+   #    Default: @size / 64 (i. e. 2 bits for default size)
+   # @return [Boolean]
+   def ==(other, cutoff=@size / 64)
       self - other < 5
    end
 
-   def display
-      @hash.map {|x| x.join() }.join("\n")
+   def display(values = nil)
+    values = @h unless values
+      [1,0].map do |matrix|
+        (0...@dimension).map do |x|
+            (0...@dimension).map do |y| 
+              values[matrix][x][y]  ? '*' : '.'
+            end.join(" ")
+        end.join("\n")
+      end.join("\n\n") + "\n"
+   end
+
+   # return [String] The concatenated row- and
+   #   column-wise matrices, compatible to the
+   #   python implementation
+   # @see https://github.com/Jetsetter/dhash
+   def matrix
+      [0,1].map do |matrix|
+         (0...@dimension).map do |x|
+            (0...@dimension).map do |y|
+               @h[matrix][x][y] ? '1' : '0'
+            end.join
+         end.join("\n")
+      end.join("\n")
    end
+
    def to_s
-      @hash.join()
+      [0,1].map do |matrix|
+         (0...@dimension).map do |x|
+            (0...@dimension).map do |y|
+               @h[matrix][x][y] ? 1 : 0
+            end.join
+         end.join
+      end.join
    end
 
+   # return [Integer] The integer of bit length
+   #    <size> representing the hash
    def to_i
-      (0..7).map {|x| (0..7).map {|y| @hash[x][y] * 2**(x*y)}}.sum
+      [0,1].map do |matrix|
+         (0...@dimension).map do |x|
+            (0...@dimension).map do |y|
+               @h[x][y] * 2**(x*y)
+            end
+         end
+      end
+      .sum
    end
-  private
-
-   def from_array(jpg)
-      return (0..7).map { |x| (0..7).map { |y|  (jpg[x][y] > jpg[x][y+1]) ? 1 : 0 }}
+   
+   private
+   def from_array(gray)
+    [:rows, :cols].map do |direction| 
+        (0...@dimension).map do |y| 
+          (0...@dimension).map do |x|
+            if direction == :rows
+              gray[x][y] <= gray[x+1][y]
+            else
+              gray[x][y] <= gray[x][y+1]
+            end
+          end
+        end
       end
-
+   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dhashy
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Matthias Winkelmann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-09 00:00:00.000000000 Z
+date: 2018-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mini_magick
@@ -16,42 +16,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.16.a
+        version: '1.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.16.a
+        version: '1.16'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -105,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Perceptive Image Hashing and Deduplication.