RubyGems - dhash-vips - Versions diffs - 0.1.1.0 → 0.1.1.3 - Mend

dhash-vips 0.1.1.0 → 0.1.1.3

Files changed (6) hide show

checksums.yaml CHANGED

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e462c5c41c5f2c5916223c083f22d16ae37a062b
-  data.tar.gz: 3261d15852334f30b59bd53cbfdd03e4a6db8758
+SHA256:
+  metadata.gz: 413fea86d6b847774a983fc962d0c47780f8e58704a7e2656d224e7eccd089dd
+  data.tar.gz: db8776fbcbb0945aac9ae50d251b04cf681b3c1e4f2f1623b4fcf96a37deaa56
 SHA512:
-  metadata.gz: 80c90dd232d5c9ea5ccfd65d715c48bafb56ca94aac70e45ced117ad27e748ae81030010f4eb62f963b86f0854d1a9c6d3f4174de730cb8f763fd7dcfcf60f89
-  data.tar.gz: bbe1bee6c35949f68fe886512668d3ea5215daa2207f49fe3f2db51b5ea3c1829d2fb7c69a4d3b05a05afab6df7d243ba37d10d6de39aae1088b404189d43326
+  metadata.gz: e60093bb301e5b79d8b0653cacef7fb8ad66b87c1a3f6bbfe34df77272ef1fe3a95919371989476467304afdf3cb25a191ddeb6d74b4141dada5fbee1008d112
+  data.tar.gz: 8b9fdbf1d4924307a0650fe81c9f66f631c807f5b18481fe207088e28153b496595b999b02d52f3179f55baf8cc4a9e7499eb86505964fb53f5b1adf70b831d8

data/dhash-vips.gemspec CHANGED

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "dhash-vips"
-  spec.version       = "0.1.1.0"
+  spec.version       = "0.1.1.3"
   spec.author        = "Victor Maslov"
   spec.email         = "nakilon@gmail.com"
   spec.summary       = "dHash and IDHash perceptual image hashing/fingerprinting"
@@ -10,11 +10,7 @@ Gem::Specification.new do |spec|
   spec.require_path  = "lib"
   spec.test_files    = %w{ test.rb }
   spec.extensions    = %w{ extconf.rb }
-  spec.files         = `git ls-files -z`.split("\x0") -
-                       spec.test_files -
-                       %w{ .gitignore Dockerfile } -
-                       Dir.glob("example_*/**/*") -
-                       Dir.glob(".github/**/*")
+  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"

data/extconf.rb CHANGED

@@ -3,15 +3,11 @@ require "mkmf"
 File.write "Makefile", dummy_makefile(?.).join
 unless Gem::Platform.local.os == "darwin" && ENV["RBENV_ROOT"] && ENV["RBENV_VERSION"]
 else
-  if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.3.8") ||
-     Gem::Version.new(RUBY_VERSION) > Gem::Version.new("2.4.9")
-  else
-    if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.4")
-    else
-      append_cppflags "-DRUBY_EXPORT"
-    end
+  unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.3.8")
     # https://github.com/rbenv/rbenv/issues/1199
-    append_cppflags "-I#{Dir.glob("#{ENV["RBENV_ROOT"]}/sources/#{ENV["RBENV_VERSION"]}/ruby-*/").first}"
+    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.
@@ -21,15 +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. everything is ok
-# `rm -rf idhash.o idhash.bundle idhash.so pkg && bundle exec rake install`
-# `bundle exec rake -rdhash-vips -e "p DHashVips::IDHash.method(:distance3).source_location"` # => # ["/Users/nakilon/_/dhash-vips/lib/dhash-vips.rb", 32]  # currently falsely says that gem install failed idk why
 # `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", 53]
+# `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

metadata CHANGED

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dhash-vips
 version: !ruby/object:Gem::Version
-  version: 0.1.1.0
+  version: 0.1.1.3
 platform: ruby
 authors:
 - Victor Maslov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-26 00:00:00.000000000 Z
+date: 2020-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-vips
@@ -145,8 +145,6 @@ extra_rdoc_files: []
 files:
 - Gemfile
 - LICENSE.txt
-- README.md
-- Rakefile
 - common.rb
 - dhash-vips.gemspec
 - extconf.rb
@@ -173,8 +171,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.6.14.4
+rubygems_version: 3.1.2
 signing_key:
 specification_version: 4
 summary: dHash and IDHash perceptual image hashing/fingerprinting

data/README.md DELETED

@@ -1,196 +0,0 @@
-[![Gem Version](https://badge.fury.io/rb/dhash-vips.svg)](http://badge.fury.io/rb/dhash-vips) [![Docker Image](https://github.com/nakilon/dhash-vips/workflows/Docker%20Image/badge.svg)](https://hub.docker.com/repository/docker/nakilonishe/dhash-vips/general)
-# 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. For even more speed the fingerprint comparison function is made as native C extension.
-## IDHash (the Important Difference Hash)
-The main improvement over the dHash is what makes it insensitive to the resizing algorithm and possible errors due to color scheme conversion.
-* 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.
-### 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)
-  * [How do I speed up this BIT_COUNT query for hamming distance?](https://stackoverflow.com/q/35065675/322020)
-  * [Hamming distance on binary strings in SQL](https://stackoverflow.com/q/4777070/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 thresholds 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':       2         2                 4                  0                     0
-          Similar images:   1..15    14..34             2..23              6..22               53..166
-        Different images:  10..54    22..42            10..50             17..65              120..233
-                1/FMI^2 =   1.375       4.0             1.556               1.25                 1.306
-                 FP, FN =  [3, 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 threshold line. Smaller number is better. The last line shows number of false positives (`FP`) and false negatives (`FN`) in case of the best achieved FMI. Here I've added the [`phamilie` gem](https://github.com/toy/phamilie) that is DCT based (not a kind of dhash).
-* 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 try to compile and use the Ruby C extension that is around 15 times faster than pure Ruby implementation -- native extension currently works on macOS rbenv Ruby from 2.3.8 to 2.4.9 installed with rbenv `-k` flag. So the full benchmark:
-  * Ruby 2.3.8p459:
-        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 (32*32*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)
-* There is now a benchmark that runs both speed and quality tests summing results to a single table where lower numbers are better:
-    ruby 2.3.8p459 (2018-10-18 revision 65136) [x86_64-darwin18]
-    vips-8.9.2-Tue Apr 21 09:26:11 UTC 2020
-    Version: ImageMagick 6.9.11-24 Q16 x86_64 2020-07-18
-    Intel(R) Core(TM) i5-7360U CPU @ 2.30GHz
-                Fingerprint  Compare  1/FMI^2
-      Phamilie        3.943    0.630    4.000
-         Dhash        4.969    1.097    1.375
-         DHash        0.434    1.089    1.556
-        IDHash        0.396    0.126    1.250
-* 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 notes
-    $ ruby test.rb
-* You might need to prepend `bundle exec` to all the `rake` commands.
-* You get this:
-        Can't install RMagick 2.16.0. Can't find MagickWand.h.
-    because Imagemagick sucks but we need it to benchmark alternative gems, so:
-        $ brew install imagemagick@6
-        $ brew unlink imagemagick@7
-        $ brew link imagemagick@6 --force
-* 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
-* 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.
-* The tag `v0.0.0.4` is not semver and not real gem version -- it's only for Github Actions testing purposes.
-* To quickly find out what does the dhash-vips Docker image include: `docker run --rm <image_name> sh -c "cat /etc/alpine-release; ruby -v; vips -v; gem list dhash-vips` (TODO: write in this README about the existing Docker image).
-* Phamilie works with filenames instead of fingerprints and caches them but not distances.
-## Credits
-[John Cupitt](https://github.com/jcupitt) (libvips and ruby-vips maintainer) helped me a lot.

data/Rakefile DELETED

@@ -1,364 +0,0 @@
-begin
-  # for `rake release`
-  require "bundler/gem_tasks"
-rescue LoadError
-  puts "consider to `gem install bundler` to be able to `rake release`"
-end
-require "pp"
-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
-desc "Benchmark speed of Dhash, DHashVips::DHash, DHashVips::IDHash and Phamilie"
-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
-  # this array manipulation converts [1, 2, 3, 4, 5] into [1, 2, 3, 4, 4, 4, 5]
-  hashes[-1, 1] = hashes[-2, 2]
-  hashes[-1, 1] = hashes[-2, 2]
-  puts "\nmeasure the distance (32*32*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
-desc "Benchmarks everything about Dhash, DHashVips::DHash, DHashVips::IDHash and Phamilie"
-task :benchmark do
-  abort "provide a folder with images grouped by similarity" unless 2 === ARGV.size
-  abort "invalid folder provided" unless Dir.exist?(dir = ARGV.last)
-  require "dhash"
-  require "phamilie"
-  phamilie = Phamilie.new
-  require_relative "lib/dhash-vips"
-  filenames = Dir.glob("#{dir}/*").map{ |_| Dir.glob "#{_}/*" }
-  puts "image groups sizes: #{filenames.map(&:size)}"
-  require "benchmark"
-  puts "step 1 / 3 (fingerprinting)"
-  hashes = []
-  bm1 = [
-    [phamilie, :fingerprint],
-    [Dhash, :calculate],
-    [DHashVips::DHash, :calculate],
-    [DHashVips::IDHash, :fingerprint],
-  ].map do |m, calc, power|
-    Benchmark.realtime do
-      hashes.push filenames.flatten.map{ |filename| m.send calc, filename, *power }
-    end
-  end
-  puts "step 2 / 3 (comparing fingerprints)"
-  combs = filenames.flatten.size ** 2
-  n = 10_000_000_000_000 / Dir.glob("#{dir}/*/*").map(&File.method(:size)).inject(:+) / combs
-  bm2 = [
-    [phamilie, :distance, nil, filenames.flatten],
-    [Dhash, :hamming],
-    [DHashVips::DHash, :hamming],
-    [DHashVips::IDHash, :distance3_c],
-  ].zip(hashes).map do |(m, dm, power, ii), hs|
-    Benchmark.realtime do
-      _ = ii || hs
-      _.product _ do |h1, h2|
-        n.times{ m.public_send dm, h1, h2 }
-      end
-    end
-  end
-  puts "step 3 / 3 (looking for the best threshold)"
-  bm3 = [
-    [phamilie, :fingerprint, :distance, nil, 0],
-    [Dhash, :calculate, :hamming],
-    [DHashVips::DHash, :calculate, :hamming],
-    [DHashVips::IDHash, :fingerprint, :distance],
-  ].map do |m, calc, dm, power, ii|
-    require_relative "common"
-    hashes = Dir.glob("#{dir}/*").flat_map{ |_| Dir.glob "#{_}/*" }.map{ |filename| [filename, m.public_send(calc, filename, *power)] }
-    report = Struct.new(:same, :sim, :not_sim).new [], [], []
-    hashes.size.times.to_a.repeated_combination(2) do |i, j|
-      report[
-        case
-        when i == j                                                   ; :same
-        when File.split(File.split(hashes[i][0]).first).last ==
-             File.split(File.split(hashes[j][0]).first).last && i < j ; :sim
-        else                                                          ; :not_sim
-        end
-      ].push m.method(dm).call hashes[i][ii||1], hashes[j][ii||1]
-    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)
-    fmi
-  end
-  puts RUBY_DESCRIPTION
-  system "vips -v"
-  system "identify -version | /usr/bin/head -1"
-  system "sysctl -n machdep.cpu.brand_string"
-  require "mll"
-  puts MLL::grid.call %w{ \  Fingerprint Compare 1/FMI^2 }.zip(*[
-    %w{ Phamilie Dhash DHash IDHash },
-    *[bm1, bm2].map{ |bm| bm.map{ |_| "%.3f" % _ } },
-    bm3.map{ |_| "%.3f" % _ }
-  ].transpose).transpose, spacings: [1.5, 0], alignment: :right
-  puts "(lower numbers are better)"
-end