dhash-vips 0.1.0.1 → 0.1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 465577547953c3039cdea1665f7010ed0af57656
-  data.tar.gz: 9bb9a40feba3b039d0c0ee12f94907dd9b23fa68
+SHA256:
+  metadata.gz: 413fea86d6b847774a983fc962d0c47780f8e58704a7e2656d224e7eccd089dd
+  data.tar.gz: db8776fbcbb0945aac9ae50d251b04cf681b3c1e4f2f1623b4fcf96a37deaa56
 SHA512:
-  metadata.gz: 5936ffe730fb274a719d812dde7dab4113c5002d3c7acaad3c58bb12ed8d1da5744f7afa9d73e728ad7b54ee14f5f1f300bf021d98eab64ed08fefbeeb5034e2
-  data.tar.gz: 19d272fa20c2f954f111561537328f677fbb32a84836e4d03d605f1086c3694b27647390b9420b36ce4fe56c7ddd8537f247729464202a0ba8a968813670237e
+  metadata.gz: e60093bb301e5b79d8b0653cacef7fb8ad66b87c1a3f6bbfe34df77272ef1fe3a95919371989476467304afdf3cb25a191ddeb6d74b4141dada5fbee1008d112
+  data.tar.gz: 8b9fdbf1d4924307a0650fe81c9f66f631c807f5b18481fe207088e28153b496595b999b02d52f3179f55baf8cc4a9e7499eb86505964fb53f5b1adf70b831d8

data/dhash-vips.gemspec

@@ -1,27 +1,28 @@
 Gem::Specification.new do |spec|
   spec.name          = "dhash-vips"
-  spec.version       = "0.1.0.1"
+  spec.version       = "0.1.1.3"
   spec.author        = "Victor Maslov"
   spec.email         = "nakilon@gmail.com"
-  spec.summary       = "dHash and IDHash powered by Vips"
+  spec.summary       = "dHash and IDHash perceptual image hashing/fingerprinting"
   spec.homepage      = "https://github.com/nakilon/dhash-vips"
   spec.license       = "MIT"
 
-  spec.test_files    = %w{ test.rb }
-  spec.files         = `git ls-files -z`.split("\x0") - spec.test_files - %w{ .gitignore } - Dir.glob("example_ocr/**")
   spec.require_path  = "lib"
+  spec.test_files    = %w{ test.rb }
   spec.extensions    = %w{ extconf.rb }
+  spec.files         = %w{ extconf.rb Gemfile LICENSE.txt common.rb dhash-vips.gemspec idhash.c lib/dhash-vips-post-install-test.rb lib/dhash-vips.rb }
 
   spec.add_dependency "ruby-vips", "~>2.0.16"
 
   spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest"
-  spec.add_development_dependency "get_process_mem"
 
   spec.add_development_dependency "rmagick", "~>2.16"
   spec.add_development_dependency "phamilie"
   spec.add_development_dependency "dhash"
 
+  spec.add_development_dependency "get_process_mem"
+
   spec.add_development_dependency "mll"
   spec.add_development_dependency "byebug"
 end

data/extconf.rb

@@ -1,13 +1,13 @@
 require "mkmf"
 
 File.write "Makefile", dummy_makefile(?.).join
-unless Gem::Platform.local.os == "darwin" && Gem::Version.new(RUBY_VERSION) == Gem::Version.new("2.3.8")
+unless Gem::Platform.local.os == "darwin" && ENV["RBENV_ROOT"] && ENV["RBENV_VERSION"]
 else
-  begin
+  unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.3.8")
     # https://github.com/rbenv/rbenv/issues/1199
-    append_cppflags "-I#{Dir.glob("#{`rbenv root`.chomp}/sources/#{`rbenv version-name`.chomp}/*/").first}"
-  rescue
-  else
+    if found = Dir.glob("#{ENV["RBENV_ROOT"]}/sources/#{ENV["RBENV_VERSION"]}/ruby-*/").first
+    append_cppflags "-I#{found}"
+    append_cppflags "-DRUBY_EXPORT" unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.4")
     create_makefile "idhash"
     # Why this hack?
     # 1. Because I want to use Ruby and ./idhash.bundle for tests, not C.
@@ -17,14 +17,16 @@ else
       test: all
       \t$(RUBY) -r./lib/dhash-vips.rb ./lib/dhash-vips-post-install-test.rb
     HEREDOC
+    end
   end
 end
 
 # Cases to check:
-# 0. all is ok
-# `rm -rf idhash.o idhash.bundle pkg && bundle exec rake install`    # w/o ext  # ["/Users/nakilon/_/dhash-vips/lib/dhash-vips.rb", 32]
-# `rm -f idhash.o idhash.bundle Makefile && ruby extconf.rb && make` # with ext # ["/Users/nakilon/_/dhash-vips/lib/dhash-vips.rb", 40]
+# 0. everything is ok
+# `rm -f idhash.o idhash.bundle idhash.so Makefile && ruby extconf.rb && make`
 # `bundle exec rake -rdhash-vips -e "p DHashVips::IDHash.method(:distance3).source_location"`
+# => # ["/Users/nakilon/_/dhash-vips/lib/dhash-vips.rb", 52] # or 42 with Ruby<2.4
+# => # ["/Users/nakilon/_/dhash-vips/lib/dhash-vips.rb", 32] # if LoadError
 # 1. not macOS && rbenv
 # 2. fail during append_cppflags
 # 3. failed compilation

data/lib/dhash-vips-post-install-test.rb

@@ -20,8 +20,20 @@ ss = s.repeated_permutation(4).map do |s1, s2, s3, s4|
   end
 end
 fail unless :distance3 == DHashVips::IDHash.method(:distance3).original_name
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.4")
+  check = lambda do |s1, s2|
+    s1.is_a?(Bignum) && s2.is_a?(Bignum)
+  end
+else
+  require "rbconfig/sizeof"
+  check = lambda do |s1, s2|
+    # https://github.com/ruby/ruby/commit/de2f7416d2deb4166d78638a41037cb550d64484#diff-16b196bc6bfe8fba63951420f843cfb4R10
+    _FIXNUM_MAX = (1 << (8 * RbConfig::SIZEOF["long"] - 2)) - 1
+    s1 > _FIXNUM_MAX && s2 > _FIXNUM_MAX
+  end
+end
 ss.product ss do |s1, s2|
-  next unless s1.is_a?(Bignum) && s2.is_a?(Bignum)
+  next unless check.call s1, s2
   unless f[s1, s2] == DHashVips::IDHash.distance3_c(s1, s2)
     p [s1, s2]
     p [s1.to_s(16).rjust(64,?0)].pack("H*").unpack("N*").map{ |_| _.to_s(2).rjust(32, ?0) }

data/lib/dhash-vips.rb

@@ -37,11 +37,25 @@ module DHashVips
     rescue LoadError
       alias_method :distance3, :distance3_ruby
     else
-      def distance3 a, b
-        if a.is_a?(Bignum) && b.is_a?(Bignum)
-          distance3_c a, b
-        else
-          distance3_ruby a, b
+      # we can't just do `defined? Bignum` because it's defined but deprecated (some internal CONST_DEPRECATED flag)
+      if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.4")
+        def distance3 a, b
+          if a.is_a?(Bignum) && b.is_a?(Bignum)
+            distance3_c a, b
+          else
+            distance3_ruby a, b
+          end
+        end
+      else
+        # https://github.com/ruby/ruby/commit/de2f7416d2deb4166d78638a41037cb550d64484#diff-16b196bc6bfe8fba63951420f843cfb4R10
+        require "rbconfig/sizeof"
+        FIXNUM_MAX = (1 << (8 * RbConfig::SIZEOF["long"] - 2)) - 1
+        def distance3 a, b
+          if a > FIXNUM_MAX && b > FIXNUM_MAX
+            distance3_c a, b
+          else
+            distance3_ruby a, b
+          end
         end
       end
     end

data/test.rb

@@ -6,6 +6,7 @@ require "dhash-vips"
 
 [
   [DHashVips::DHash, :hamming, :calculate, 2, 23, 18, 50, 4],
+    # vips-8.9.1-Tue Jan 28 13:05:46 UTC 2020
     # [[0, 14, 26, 27, 31, 27, 32, 28, 43, 43, 34, 37, 37, 34, 35, 42],
     #  [14, 0, 28, 25, 39, 35, 32, 32, 43, 43, 38, 41, 41, 38, 37, 50],
     #  [26, 28, 0, 13, 35, 41, 28, 30, 41, 41, 36, 33, 35, 32, 27, 36],
@@ -23,22 +24,23 @@ require "dhash-vips"
     #  [35, 37, 27, 26, 40, 34, 23, 27, 28, 28, 29, 30, 26, 21, 0, 23],
     #  [42, 50, 36, 33, 31, 27, 34, 34, 27, 27, 18, 19, 23, 26, 23, 0]]
   [DHashVips::IDHash, :distance, :fingerprint, 6, 22, 23, 65, 0],
-    # [[0, 17, 32, 35, 57, 45, 51, 50, 48, 47, 54, 48, 60, 50, 47, 56],
-    #  [17, 0, 30, 35, 58, 46, 54, 55, 47, 51, 57, 49, 62, 52, 52, 60],
+    # vips-8.9.1-Tue Jan 28 13:05:46 UTC 2020
+    # [[0, 16, 32, 35, 57, 45, 51, 50, 48, 47, 54, 48, 60, 50, 47, 56],
+    #  [16, 0, 30, 34, 58, 47, 55, 56, 47, 50, 57, 49, 62, 52, 52, 61],
     #  [32, 30, 0, 9, 47, 54, 45, 41, 65, 62, 42, 37, 51, 44, 49, 49],
-    #  [35, 35, 9, 0, 54, 64, 42, 40, 57, 56, 48, 39, 50, 40, 41, 51],
+    #  [35, 34, 9, 0, 54, 64, 42, 40, 57, 56, 48, 39, 50, 40, 41, 51],
     #  [57, 58, 47, 54, 0, 22, 43, 45, 64, 61, 48, 47, 35, 43, 47, 48],
-    #  [45, 46, 54, 64, 22, 0, 53, 54, 55, 54, 40, 46, 39, 42, 43, 42],
-    #  [51, 54, 45, 42, 43, 53, 0, 6, 33, 35, 52, 43, 46, 45, 44, 47],
-    #  [50, 55, 41, 40, 45, 54, 6, 0, 38, 41, 53, 50, 48, 45, 41, 42],
+    #  [45, 47, 54, 64, 22, 0, 53, 54, 55, 54, 40, 46, 39, 42, 43, 42],
+    #  [51, 55, 45, 42, 43, 53, 0, 6, 33, 35, 52, 43, 46, 45, 44, 47],
+    #  [50, 56, 41, 40, 45, 54, 6, 0, 38, 41, 53, 50, 48, 45, 41, 42],
     #  [48, 47, 65, 57, 64, 55, 33, 38, 0, 9, 51, 53, 47, 47, 41, 46],
-    #  [47, 51, 62, 56, 61, 54, 35, 41, 9, 0, 51, 57, 50, 49, 44, 43],
+    #  [47, 50, 62, 56, 61, 54, 35, 41, 9, 0, 51, 57, 50, 49, 44, 43],
     #  [54, 57, 42, 48, 48, 40, 52, 53, 51, 51, 0, 10, 33, 36, 38, 25],
     #  [48, 49, 37, 39, 47, 46, 43, 50, 53, 57, 10, 0, 27, 30, 37, 27],
     #  [60, 62, 51, 50, 35, 39, 46, 48, 47, 50, 33, 27, 0, 20, 23, 28],
     #  [50, 52, 44, 40, 43, 42, 45, 45, 47, 49, 36, 30, 20, 0, 35, 39],
     #  [47, 52, 49, 41, 47, 43, 44, 41, 41, 44, 38, 37, 23, 35, 0, 19],
-    #  [56, 60, 49, 51, 48, 42, 47, 42, 46, 43, 25, 27, 28, 39, 19, 0]]
+    #  [56, 61, 49, 51, 48, 42, 47, 42, 46, 43, 25, 27, 28, 39, 19, 0]]
 ].each do |lib, dm, calc, min_similar, max_similar, min_not_similar, max_not_similar, bw_exceptional|
 
   describe lib do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dhash-vips
 version: !ruby/object:Gem::Version
-  version: 0.1.0.1
+  version: 0.1.1.3
 platform: ruby
 authors:
 - Victor Maslov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-09 00:00:00.000000000 Z
+date: 2020-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-vips
@@ -53,35 +53,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: get_process_mem
+  name: rmagick
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.16'
 - !ruby/object:Gem::Dependency
-  name: rmagick
+  name: phamilie
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.16'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.16'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: phamilie
+  name: dhash
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -95,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: dhash
+  name: get_process_mem
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -145,8 +145,6 @@ extra_rdoc_files: []
 files:
 - Gemfile
 - LICENSE.txt
-- README.md
-- Rakefile
 - common.rb
 - dhash-vips.gemspec
 - extconf.rb
@@ -173,10 +171,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: dHash and IDHash powered by Vips
+summary: dHash and IDHash perceptual image hashing/fingerprinting
 test_files:
 - test.rb

data/README.md

@@ -1,211 +0,0 @@
-[![Gem Version](https://badge.fury.io/rb/dhash-vips.svg)](http://badge.fury.io/rb/dhash-vips)
-
-# dHash and IDHash gem powered by ruby-vips
-
-The **dHash** is the algorithm of image fingerprinting that can be used to measure the similarity of two images.  
-The **IDHash** is the new algorithm that has some improvements over dHash -- I'll describe it further.
-
-You can read about the dHash and perceptual hashing in the article ["Kind of Like That" at "The Hacker Factor Blog"](http://www.hackerfactor.com/blog/index.php?/archives/529-Kind-of-Like-That.html) (21 January 2013). The idea is that you resize the otiginal image to 8x9 and then convert it to 8x8 array of bits -- each tells if the corresponding segment of the image is brighter or darker than the one on the right (or left). Then you apply the [Hamming distance](https://en.wikipedia.org/wiki/Hamming_distance) to such arrays to measure how much they are different.
-
-There were several Ruby implementations on Github already but they all depended on ImageMagick. My implementation takes an advantage of speed of the libvips (the `ruby-vips` gem) -- it fingerprints images much faster:
-
-    load the image and calculate the fingerprint:
-                              user     system      total        real
-    Dhash                 6.191731   0.230885   6.422616 (  6.428763)
-    DHashVips::DHash      0.858045   0.144820   1.002865 (  0.924308)
-
-`Dhash` here is [another gem](https://github.com/maccman/dhash) that I used earlier in my projects before I decided to make this one.  
-Unfortunately both gems made slightly different fingerprints for two image files that are supposed to have the same fingerprint because from the human point of view they are the same (photo by Jordan Voth):  
-![](https://storage.googleapis.com/dhash-vips.nakilon.pro/dhash_issue_example.png)  
-The distance here appeared to be equal to 5. This is why I've decided to improve the algorithm and this is how the "IDHash" appeared.
-
-## IDHash (the Important Difference Hash)
-
-The main improvement over the dHash is what makes it insensitive to the resizing algorithm, color scheme and effectively made the pair of images above to have a distance of 0.
-
-* The "Importance" is an array of extra 64 bits that tells the comparing function which half of 64 bits is important (when the difference between neighbors was enough significant) and which is not. So not every bit in a fingerprint is being compared but only half of them.  
-* It subtracts not only horizontally but also vertically -- that adds 128 more bits.  
-* Instead of resizing to 8x9 it resizes to 8x8 and puts the image on a torus so it subtracts the very left column from the very right one and the top from the bottom.
-
-You could see in fingerprint calculation benchmark earlier that these improvements didn't make it slower than dHash because most of the time is spent on image resizing. Distance measurement is what became slower.
-
-### Example
-
-Here are two photos (by Brian Lauer):  
-![](https://storage.googleapis.com/dhash-vips.nakilon.pro/idhash_example_in.png)  
-and visualization of IDHash (`rake compare_images -- image1.jpg image2.jpg`):  
-![](https://storage.googleapis.com/dhash-vips.nakilon.pro/idhash_example_out.png)  
-
-Here in each of 64 cells, there are two circles that color the difference between that cell and the neighbor one. If the difference is low the Importance bit is set to zero and the circle is invisible. So there are 128 pairs of corresponding circles and when you take one, if at least one circle is visible and is of different color the line is to be drawn. Here you see 15 lines and so the distance between fingerprints will be equal to 15 (that is pretty low and can be interpreted as "images look similar"). Also, you see here that floor on this photo matters -- classic dHash won't see that it's darker than wall because it's comparing only horizontal neighbors and if one photo had no floor the distance function won't notice that. Also, it sees the Important difference between the very right and left columns because the wall has a slow but visible gradient.
-
-### Remaining problems
-
-* Neither dHash nor IDHash can't automatically detect very shifted crops and rotated images but you can make a wrapper that would call the comparison function iteratively.  
-* These algorithms are color blind because of converting an image to grayscale. If you take a photo of something in your yard the sun will create lights and shadows, but if you compare photos of something green painted on a blue wall there is a possibility the machine would see nothing painted at all. The `dhash` gem had such image in specs and that made them pretty useless (this was supposed to be a face):  
-![](https://storage.googleapis.com/dhash-vips.nakilon.pro/colorblind.png)  
-* If you have a pile of 1000000 images comparing them with each other would take a month or two. To improve the process in case of dHash that uses Hamming distance you may want to read these threads on Stackexchange network:  
-  * [How to find the closest pairs of a string of binary bins in Ruby without O^2 issues?](https://stackoverflow.com/q/8734034/322020)  
-  * [Find all pairs of values that are close under Hamming distance](https://cstheory.stackexchange.com/q/18516/27420)  
-  * [Finding the closest pair between two sets of points on the hypercube](https://cstheory.stackexchange.com/q/16322/27420)  
-  * [Would PCA work for boolean data types?](https://stats.stackexchange.com/q/159705/1125)  
-  * [Using pHash to search agaist a huge image database, what is the best approach?](https://stackoverflow.com/q/18257641/322020)  
-
-## Installation
-
-    brew install vips
-
-If you have troubles, see https://jcupitt.github.io/libvips/install.html  
-Then:
-
-    gem install dhash-vips
-
-If you have troubles with the `gem ruby-vips` dependency, see https://github.com/libvips/ruby-vips
-
-## Usage
-
-### dHash:
-
-```ruby
-require "dhash-vips"
-
-hash1 = DHashVips::DHash.calculate "photo1.jpg"
-hash2 = DHashVips::DHash.calculate "photo2.jpg"
-
-distance = DHashVips::DHash.hamming hash1, hash2
-if distance < 10
-  puts "Images are very similar"
-elsif distance < 20
-  puts "Images are slightly similar"
-else
-  puts "Images are different"
-end
-```
-
-### IDHash:
-
-```ruby
-require "dhash-vips"
-
-hash1 = DHashVips::IDHash.fingerprint "photo1.jpg"
-hash2 = DHashVips::IDHash.fingerprint "photo2.jpg"
-
-distance = DHashVips::IDHash.distance hash1, hash2
-if distance < 15
-  puts "Images are very similar"
-elsif distance < 25
-  puts "Images are slightly similar"
-else
-  puts "Images are different"
-end
-```
-
-### Notes and benchmarks
-
-* The above `15` and `25` constants are found empirically and just work enough well for 8-byte hashes. To find these tresholds we can run a rake task with hardcoded test cases (pairs of photos from the same photosession are not the same but are considered to be enough 'similar' for the purpose of this benchmark):
-
-      $ rake compare_quality
-
-                            Dhash  Phamilie  DHashVips::DHash  DHashVips::IDHash  DHashVips::IDHash(4) 
-          The same image:    0..0      0..0              0..0               0..0                  0..0 
-      'Jordan Voth case':       4         2                 4                  0                     0 
-          Similar images:   1..17    14..34             2..23              6..22               53..166 
-        Different images:   9..57    22..42             9..50             18..65              120..233 
-                1/FMI^2 =    1.25       4.0             1.556               1.25                 1.306 
-                 FP, FN =  [2, 0]    [0, 6]            [1, 2]             [2, 0]                [1, 1] 
-
-    The `FMI` line here is the "quality of algorithm", i.e. the best achievable function from the ["Fowlkes–Mallows index"](https://en.wikipedia.org/wiki/Fowlkes%E2%80%93Mallows_index) value if you take the "similar" and "different" test pairs and try to draw the treshold line. Smaller number is better. Here I've added the [`phamilie` gem](https://github.com/toy/phamilie) that is DCT based (not a kind of dhash). The last line shows number of false positives (`FP`) and false negatives (`FN`) in case of the best achieved FMI.
-
-* Methods were renamed from `#calculate` to `#fingerprint` and from `#hamming` to `#distance`.  
-* The `DHash#calculate` accepts `hash_size` optional parameter that is 8 by default. The `IDHash#fingerprint`'s optional parameter is called `power` and works in a bit different way: 3 means 8 and 4 means 16 -- other sizes are not supported because they don't seem to be useful (higher fingerprint resolution makes it vulnerable to image shifts and croppings, also `#distance` becomes much slower). Because IDHash's fingerprint is more complex than DHash's one it's not that straight forward to compare them so under the hood the `#distance` method have to check the size of fingerprint. If you are sure that fingerprints were made with power=3 then to skip the check you may use the `#distance3` method directly.  
-* The `#distance3` method will use Ruby C extension that is around 15 times faster than pure Ruby implementation -- native extension is currently hardcoded to be compiled only if it's macOS and rbenv Ruby 2.3.8 installed with `-k` flag but if you know how to make the gem gracefully fallback to native Ruby if `make` fails let me know or make a pull request. So the full benchmark:
-
-  * Ruby 2.0.0
-
-        $ bundle exec rake compare_speed
-
-        load the image and calculate the fingerprint:
-                                  user     system      total        real
-        Dhash                12.400000   0.820000  13.220000 ( 13.329952)
-        DHashVips::DHash      1.330000   0.230000   1.560000 (  1.509826)
-        DHashVips::IDHash     1.060000   0.090000   1.150000 (  1.100332)
-        DHashVips::IDHash 4   1.030000   0.080000   1.110000 (  1.089148)
-
-        measure the distance (1000 times):
-                                            user     system      total        real
-        Dhash hamming                   3.140000   0.020000   3.160000 (  3.179392)
-        DHashVips::DHash hamming        3.040000   0.020000   3.060000 (  3.095190)
-        DHashVips::IDHash distance      8.170000   0.040000   8.210000 (  8.279950)
-        DHashVips::IDHash distance3     6.720000   0.030000   6.750000 (  6.790900)
-        DHashVips::IDHash distance 4   24.430000   0.130000  24.560000 ( 24.652625)
-
-  * Ruby 2.3.3 seems to have some bit arithmetics improvement compared to 2.0:
-
-        load the image and calculate the fingerprint:
-                                  user     system      total        real
-        Dhash                13.110000   0.950000  14.060000 ( 14.537057)
-        DHashVips::DHash      1.480000   0.310000   1.790000 (  1.808787)
-        DHashVips::IDHash     1.080000   0.100000   1.180000 (  1.156446)
-        DHashVips::IDHash 4   1.030000   0.090000   1.120000 (  1.076117)
-
-        measure the distance (1000 times):
-                                            user     system      total        real
-        Dhash hamming                   1.770000   0.010000   1.780000 (  1.815612)
-        DHashVips::DHash hamming        1.810000   0.010000   1.820000 (  1.875666)
-        DHashVips::IDHash distance      4.250000   0.020000   4.270000 (  4.350071)
-        DHashVips::IDHash distance3     3.430000   0.020000   3.450000 (  3.499031)
-        DHashVips::IDHash distance 4    8.210000   0.110000   8.320000 (  8.510735)
-
-  * Ruby 2.3.8p459 (2.4.6, 2.5.5 and 2.6.3 are all similar) with newer CPU (`sysctl -n machdep.cpu.brand_string #=> Intel(R) Core(TM) i5-7360U CPU @ 2.30GHz`):
-
-        load the image and calculate the fingerprint:
-                                  user     system      total        real
-        Dhash                 6.191731   0.230885   6.422616 (  6.428763)
-        Phamilie              5.361751   0.037524   5.399275 (  5.402553)
-        DHashVips::DHash      0.858045   0.144820   1.002865 (  0.924308)
-        DHashVips::IDHash     0.769975   0.071087   0.841062 (  0.790470)
-        DHashVips::IDHash 4   0.805311   0.077918   0.883229 (  0.825897)
-
-        measure the distance (2000 times):
-                                               user     system      total        real
-        Dhash hamming                      1.810000   0.000000   1.810000 (  1.824719)
-        Phamilie distance                  1.000000   0.010000   1.010000 (  1.006127)
-        DHashVips::DHash hamming           1.810000   0.000000   1.810000 (  1.817415)
-        DHashVips::IDHash distance         1.400000   0.000000   1.400000 (  1.401333)
-        DHashVips::IDHash distance3_ruby   3.320000   0.010000   3.330000 (  3.337920)
-        DHashVips::IDHash distance3_c      0.210000   0.000000   0.210000 (  0.212864)
-        DHashVips::IDHash distance 4       8.300000   0.120000   8.420000 (  8.499735)
-
-* Also note that to make `#distance` able to assume the fingerprint resolution from the size of Integer that represents it, the change in its structure was needed (left half of bits was swapped with right one), so fingerprints between versions 0.0.4 and 0.0.5 became incompatible, but you probably can convert them manually. Otherwise if we put the version or structure information inside fingerprint it would became slow to (de)serialize and store.
-
-## Development
-
-* OS X El Captain and rbenv may cause environment issues that would make you do things like:
-
-        $ ./ruby `rbenv which rake` compare_matrixes
-
-    instead of just
-
-        $ rake compare_matrixes
-
-    For more information on that: https://github.com/jcupitt/ruby-vips/issues/141
-
-* On macOS, when you do `bundle install` it may fail to install `rmagick` gem (`dhash` gem dependency) saying:
-
-        ERROR: Can't install RMagick 4.0.0. Can't find magick/MagickCore.h.
-
-    To resolve this do:
-
-        $ brew install imagemagick@6
-        $ LDFLAGS="-L/usr/local/opt/imagemagick@6/lib" CPPFLAGS="-I/usr/local/opt/imagemagick@6/include" bundle install
-
-* If you get `No package 'MagickCore' found` try:
-
-        $ PKG_CONFIG_PATH="/usr/local/Cellar/imagemagick@6/6.9.10-74/lib/pkgconfig" bundle install
-
-* You might need to prepend `bundle exec` to all the `rake` commands.
-
-* Execute the `rake compare_quality` at least once before executing other rake tasks because it's currently the only one that downloads the test images.
-
-## Credits
-
-[John Cupitt](https://github.com/jcupitt) (libvips and ruby-vips maintainer) helped me a lot.

data/Rakefile

@@ -1,273 +0,0 @@
-STDOUT.sync = true
-require "pp"
-
-require "bundler/gem_tasks" # to push to rubygems
-
-visualize_hash = lambda do |hash|
-  puts hash.to_s(2).rjust(64, ?0).gsub(/(?<=.)/, '\0 ').scan(/.{16}/)
-end
-
-desc "Compare how Vips and ImageMagick resize images to 9x8"
-task :compare_pixelation do |_|
-  require_relative "lib/dhash-vips"
-  require "dhash"
-
-  ARGV.drop(1).each do |arg|
-    FileUtils.mkdir_p "compare_pixelation/#{File.dirname arg}"
-
-    puts filename = "compare_pixelation/#{arg}.dhash-vips.png"
-    DHashVips::DHash.pixelate(arg, 8).
-      colourspace(:srgb).       # otherwise we may get `Vips::Error` `RGB color space not permitted on grayscale PNG` when the image was already bw
-      write_to_file filename
-    visualize_hash.call DHashVips::DHash.calculate arg
-
-    puts filename = "compare_pixelation/#{arg}.dhash.png"
-    Magick::Image.read(arg).first.quantize(256, Magick::Rec601LumaColorspace, Magick::NoDitherMethod, 8).resize!(9, 8).
-      write filename
-    visualize_hash.call Dhash.calculate arg
-  end
-end
-
-desc "Compare how Vips resizes image to 9x8 with different kernels"
-task :compare_kernels do |_|
-  require_relative "lib/dhash-vips"
-  # require "dhash"
-
-  %i{ nearest linear cubic lanczos2 lanczos3 }.each do |kernel|
-    hashes = ARGV.drop(1).map do |arg|
-      puts arg
-      DHashVips::DHash.calculate(arg, 8, kernel).tap &visualize_hash
-    end
-    puts "kernel: #{kernel}, distance: #{DHashVips::DHash.hamming *hashes}"
-  end
-end
-
-desc "Compare the quality of Dhash, Phamilie, DHashVips::DHash, DHashVips::IDHash"
-# in this test we want to know not that photos are the same but rather that they are from the same photosession
-task :compare_quality do
-  require "dhash"
-  require "phamilie"
-  phamilie = Phamilie.new
-  require_relative "lib/dhash-vips"
-  require "mll"
-
-  puts MLL::grid.call( [
-    ["", "The same image:", "'Jordan Voth case':", "Similar images:", "Different images:", "1/FMI^2 =", "FP, FN ="],
-    *[
-      [Dhash, :calculate, :hamming],
-      [phamilie, :fingerprint, :distance, nil, 0],
-      [DHashVips::DHash, :calculate, :hamming],
-      [DHashVips::IDHash, :fingerprint, :distance],
-      [DHashVips::IDHash, :fingerprint, :distance, 4],
-    ].map do |m, calc, dm, power, ii|
-      require_relative "common"
-      hashes = %w{
-        71662d4d4029a3b41d47d5baf681ab9a.jpg ad8a37f872956666c3077a3e9e737984.jpg
-
-        1b1d4bde376084011d027bba1c047a4b.jpg 6d97739b4a08f965dc9239dd24382e96.jpg
-
-        1d468d064d2e26b5b5de9a0241ef2d4b.jpg 92d90b8977f813af803c78107e7f698e.jpg
-        309666c7b45ecbf8f13e85a0bd6b0a4c.jpg 3f9f3db06db20d1d9f8188cd753f6ef4.jpg
-        679634ff89a31279a39f03e278bc9a01.jpg df0a3b93e9412536ee8a11255f974141.jpg
-        54192a3f65bd03163b04849e1577a40b.jpg 6d32f57459e5b79b5deca2a361eb8c6e.jpg
-        4b62e0eef58bfbc8d0d2fbf2b9d05483.jpg b8eb0ca91855b657f12fb3d627d45c53.jpg
-        21cd9a6986d98976b6b4655e1de7baf4.jpg 9b158c0d4953d47171a22ed84917f812.jpg
-        9c2c240ec02356472fb532f404d28dde.jpg fc762fa286489d8afc80adc8cdcb125e.jpg
-        7a833d873f8d49f12882e86af1cc6b79.jpg ac033cf01a3941dd1baa876082938bc9.jpg
-      }.map(&method(:download_and_keep)).map{ |filename| [filename, m.public_send(calc, filename, *power)] }
-      table = MLL::table[m.method(dm), [hashes.map{|_|_[ii||1]}], [hashes.map{|_|_[ii||1]}]]
-      report = Struct.new(:same, :bw, :sim, :not_sim).new [], [], [], []
-      hashes.size.times.to_a.repeated_combination(2) do |i, j|
-        report[
-          case
-          when i == j                            ; :same
-          when [i, j] == [0, 1]                  ; :bw
-          when i > 3 && i + 1 == j && i % 2 == 0 ; :sim
-          else                                   ; :not_sim
-          end
-        ].push table[i][j]
-      end
-      min, max = [*report.sim, *report.not_sim].minmax
-      fmi, fp, fn = (min..max+1).map do |b|
-        fp = report.not_sim.count{ |_| _ < b }
-        tp = report.sim.count{ |_| _ < b }
-        fn = report.sim.count{ |_| _ >= b }
-        [((tp + fp) * (tp + fn)).fdiv(tp * tp), fp, fn]
-      end.reject{ |_,| _.nan? }.min_by(&:first)
-      [
-        "#{m.is_a?(Module) ? m : m.class}#{"(#{power})" if power}",
-        report.same.   minmax.join(".."),
-        report.bw[0],
-        report.sim.    minmax.join(".."),
-        report.not_sim.minmax.join(".."),
-        fmi.round(3),
-        [fp, fn]
-      ]
-    end,
-  ].transpose, spacings: [1.5, 0], alignment: :right )
-end
-
-# ruby -c Rakefile && rm -f ab.png && rake compare_images -- fc762fa286489d8afc80adc8cdcb125e.jpg 9c2c240ec02356472fb532f404d28dde.jpg 2>/dev/null && ql ab.png
-# rm -f ab.png && ./ruby `rbenv which rake` compare_images -- 6d97739b4a08f965dc9239dd24382e96.jpg 1b1d4bde376084011d027bba1c047a4b.jpg 2>/dev/null && ql ab.png
-desc "Visualizes the IDHash difference measurement between two images"
-task :compare_images do |_|
-  abort "there should be two image filenames passed as arguments (and optionally the `power`)" unless (3..4) === ARGV.size
-  abort "the optional argument should be either 3 or 4" unless [3, 4].include?(power = (ARGV[3] || 3).to_i)
-  task ARGV.last do ; end
-  require_relative "lib/dhash-vips"
-  ha, hb = ARGV[1, 2].map{ |filename| DHashVips::IDHash.fingerprint(filename, power) }
-  puts "distance: #{DHashVips::IDHash.distance ha, hb}"
-  size = 2 ** power
-  shift = 2 * size * size
-  ai = ha >> shift
-  ad = ha - (ai << shift)
-  bi = hb >> shift
-  bd = hb - (bi << shift)
-
-  a, b = ARGV[1, 2].map do |filename|
-    image = Vips::Image.new_from_file filename
-    image = image.resize(size.fdiv(image.width), vscale: size.fdiv(image.height)).colourspace("b-w").
-                  resize(100, vscale: 100, kernel: :nearest).colourspace("srgb")
-  end
-  fail unless a.width == b.width && a.height == b.height
-
-  _127 = shift - 1
-  _63 = size * size - 1
-  n = 0
-  width = a.width
-  height = a.height
-
-  Vips::Operation.class_eval do
-    old_initialize = instance_method :initialize
-    define_method :initialize do |value|
-      old_initialize.bind(self).(value).tap do
-        self.instance_variable_set "@operation_name", value
-      end
-    end
-    old_set = instance_method :set
-    define_method :set do |*args|
-      args[1].instance_variable_set "@operation_name", self.instance_variable_get("@operation_name") if args.first == "image"
-      old_set.bind(self).(*args)
-    end
-  end
-  Vips::Image.class_eval do
-    def copy
-      return self if caller.first.end_with?("/gems/ruby-vips-2.0.9/lib/vips/operation.rb:148:in `set'") &&
-                     %w{ draw_line draw_circle }.include?(instance_variable_get "@operation_name")
-      method_missing :copy
-    end
-  end
-
-  require "get_process_mem"
-  a, b = [[a, ad, ai], [b, bd, bi]].map do |image, xd, xi|
-    _127.downto(0).each_with_index do |i, ii|
-      mem = GetProcessMem.new(Process.pid).mb
-      abort ">1000mb of memory consumed" if 1000 < mem
-      if i > _63
-        y, x = (_127 - i).divmod size
-      else
-        x, y = (_63 - i).divmod size
-      end
-      x = (width  * (x + 0.5) / size).round
-      y = (height * (y + 0.5) / size).round
-      if i > _63
-        (x-2..x+2).map do |x| [
-          [x,  y                                  , x, (y + height / size / 2 - 1) % height],
-          [x, (y + height / size / 2 + 1) % height, x, (y + height / size        ) % height],
-        ] end
-      else
-        (y-2..y+2).map do |y| [
-          [ x                                , y, (x + width / size / 2 - 1) % width, y],
-          [(x + width / size / 2 + 1) % width, y, (x + width / size        ) % width, y],
-        ] end
-      end.each do |coords1, coords2|
-        n += 1
-        image = image.draw_line (1 - xd[i]) * 255, *coords1
-        image = image.draw_line      xd[i]  * 255, *coords2
-      end if ai[i] + bi[i] > 0 && ad[i] != bd[i]
-      cx, cy = if i > _63
-        [x, y + 30]
-      else
-        [x + 30, y]
-      end
-      image = image.draw_circle      xd[i]  * 255, cx, cy, 11, fill: true if xi[i] > 0
-      image = image.draw_circle (1 - xd[i]) * 255, cx, cy, 10, fill: true if xi[i] > 0
-    end
-    image
-  end
-  puts "distance: #{n / 10}"
-  puts "(above should be equal if raketask works correcly)"
-
-  a.join(b, :horizontal, shim: 15).write_to_file "ab.png"
-end
-
-# ./ruby `rbenv which rake` compare_speed
-desc "Benchmarks Dhash, DHashVips::DHash and DHashVips::IDHash"
-task :compare_speed do
-  require "dhash"
-  require "phamilie"
-  phamilie = Phamilie.new
-  require_relative "lib/dhash-vips"
-
-  filenames = %w{
-    71662d4d4029a3b41d47d5baf681ab9a.jpg
-    ad8a37f872956666c3077a3e9e737984.jpg
-    1d468d064d2e26b5b5de9a0241ef2d4b.jpg
-    92d90b8977f813af803c78107e7f698e.jpg
-    309666c7b45ecbf8f13e85a0bd6b0a4c.jpg
-    3f9f3db06db20d1d9f8188cd753f6ef4.jpg
-    df0a3b93e9412536ee8a11255f974141.jpg
-    679634ff89a31279a39f03e278bc9a01.jpg
-  }.flat_map do |filename|
-    image = Vips::Image.new_from_file "images/#{filename}"
-    [0, 1, 2, 3].map do |a|
-      "benchmark/#{a}_#{filename}".tap do |filename|
-        next if File.exist? filename
-        FileUtils.mkdir_p "benchmark"
-        image.rot(a).write_to_file filename
-      end
-    end
-  end
-
-  require "benchmark"
-  puts "load the image and calculate the fingerprint:"
-  hashes = []
-  Benchmark.bm 19 do |bm|
-    [
-      [Dhash, :calculate],
-      [phamilie, :fingerprint],
-      [DHashVips::DHash, :calculate],
-      [DHashVips::IDHash, :fingerprint],
-      [DHashVips::IDHash, :fingerprint, 4],
-    ].each do |m, calc, power|
-      bm.report "#{m.is_a?(Module) ? m : m.class} #{power}" do
-        hashes.push filenames.map{ |filename| m.send calc, filename, *power }
-      end
-    end
-  end
-
-  # for `distance`, `distance3_ruby` and `distance3_c` we use the same hashes
-  hashes[-1, 1] = hashes[-2, 2]
-  hashes[-1, 1] = hashes[-2, 2]
-
-  puts "\nmeasure the distance (2000 times):"
-  Benchmark.bm 32 do |bm|
-    [
-      [Dhash, :hamming],
-      [phamilie, :distance, nil, 1],
-      [DHashVips::DHash, :hamming],
-      [DHashVips::IDHash, :distance],
-      [DHashVips::IDHash, :distance3_ruby],
-      [DHashVips::IDHash, :distance3_c],
-      [DHashVips::IDHash, :distance, 4],
-    ].zip(hashes) do |(m, dm, power, ii), hs|
-      bm.report "#{m.is_a?(Module) ? m : m.class} #{dm} #{power}" do
-        _ = [hs, filenames][ii || 0]
-        _.product _ do |h1, h2|
-          2000.times{ m.public_send dm, h1, h2 }
-        end
-      end
-    end
-  end
-
-end