blockhash 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7b43e3ea031b810952658ae5a1d250071bcfb6cc0ad30563b5ef37f678b097de
+  data.tar.gz: f541fe84b1646f6997c2d874daad48c7d6f8014490218e62e64e67141e9fb2f6
+SHA512:
+  metadata.gz: c853a8df57ff3ec69fad34d4d08a08b666dc7c41a0dc006c9a9db725b9b8aac2f24a78d4778a5ec3f6c7ed02b5a4ad30857aed255cc593ec722518ce24e4ee31
+  data.tar.gz: 6a0ba1da3475a44ebe9fb14666377c602286d20a1e693271d32c6032805d41b1353dcf492b6fa210eee2898e25e5fcee201ded9fff82fbe651b638f4688138f5

data/LICENSE

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

data/README.md

@@ -0,0 +1,67 @@
+# Blockhash
+
+This is Ruby Gem that can be used to produce and compare perceptual image hashes.
+
+This Gem is a translation of the algorithm at [http://blockhash.io](http://blockhash.io)
+
+## Installation
+
+### Prerequisites
+
+On Debian/Ubuntu/Mint you can run:
+```sh
+sudo apt get install libmagickwand-dev
+```
+
+On Arch you can run:
+```sh
+pacman -Syy pkg-config imagemagick
+```
+
+On macOS, you can run:
+```sh
+brew install pkg-config imagemagick
+```
+
+### Gem Install
+
+Install via Bundler
+```sh
+bundle add blockhash
+```
+
+Or install via RubyGems:
+```sh
+gem install blockhash
+```
+
+## Usage
+
+```ruby
+require "blockhash"
+require "rmagick"
+
+image1 = Magick::Image.read("image1.png").first
+image2 = Magick::Image.read("image2.png").first
+
+# Generate full image hashes
+hash1 = blockhash.calculate(image1, bits = 16)
+hash2 = blockhash.calculate(image2, bits = 16)
+
+# Generate fast image hashes
+hash1 = blockhash.calculate_fast(image1, bits = 16)
+hash2 = blockhash.calculate_fast(image2, bits = 16)
+
+# Generate image hash from file path
+hash1 = blockhash.calculate_from_path("image1.png", bits = 16)
+
+# Determine if hashes are similar
+similar = blockhash.similar?(hash1, hash2, threshold = 10)
+
+# Calculate distance between two hashes
+distance = blockhash.distance(hash1, hash2)
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/actuallydamo/blockhash-ruby.

data/lib/blockhash/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Blockhash
+  VERSION = "0.1.0"
+end

data/lib/blockhash.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "blockhash/version"
+require "rmagick"
+# Blockhash module
+module Blockhash
+  DEFAULT_BITS = 16
+
+  def self.distance(hash1, hash2)
+    (hash1.to_i(16) ^ hash2.to_i(16)).to_s(2).count("1")
+  end
+
+  def self.similar?(hash1, hash2, thresh = 10)
+    distance(hash1, hash2) < thresh
+  end
+
+  def self.calculate_fast(img, bits = DEFAULT_BITS)
+    if img.alpha?
+      total_value = method(:total_value_rgba)
+      img_data = img.export_pixels(0, 0, img.columns, img.rows, "RGBA")
+    else
+      total_value = method(:total_value_rgb)
+      img_data = img.export_pixels(0, 0, img.columns, img.rows, "RGB")
+    end
+    blocksize_y = img.rows / bits
+    blocksize_x = img.columns / bits
+    # Loop through each block
+    result = (0...bits).flat_map do |y|
+      (0...bits).map do |x|
+        # Sum all pixels in block
+        (0...blocksize_y).sum do |iy|
+          cy = (y * blocksize_y) + iy
+          (0...blocksize_x).sum do |ix|
+            cx = (x * blocksize_x) + ix
+            total_value.call(img_data, img.columns, cx, cy)
+          end
+        end
+      end
+    end
+    bits_to_hexhash(blocks_to_bits(result, blocksize_y * blocksize_x))
+  end
+
+  def self.calculate(img, bits = DEFAULT_BITS)
+    even_x = (img.columns % bits).zero?
+    even_y = (img.rows % bits).zero?
+    return calculate_fast(img, bits) if even_x && even_y
+
+    if img.alpha?
+      total_value = method(:total_value_rgba)
+      img_data = img.export_pixels(0, 0, img.columns, img.rows, "RGBA")
+    else
+      total_value = method(:total_value_rgb)
+      img_data = img.export_pixels(0, 0, img.columns, img.rows, "RGB")
+    end
+
+    blocks = Array.new(bits**2, 0)
+    block_width = img.columns / bits.to_f
+    block_height = img.rows / bits.to_f
+
+    (0...img.rows).each do |y|
+      b_top, b_bottom, w_top, w_bottom = block_overlaps(y, img.rows, block_height, even_y)
+      top_index = b_top * bits
+      bottom_index = b_bottom * bits
+      (0...img.columns).each do |x|
+        value = total_value.call(img_data, img.columns, x, y)
+        b_left, b_right, w_left, w_right = block_overlaps(x, img.columns, block_width, even_x)
+        blocks[top_index + b_left] += value * w_top * w_left
+        blocks[top_index + b_right] += value * w_top * w_right
+        blocks[bottom_index + b_left] += value * w_bottom * w_left
+        blocks[bottom_index + b_right] += value * w_bottom * w_right
+      end
+    end
+    bits_to_hexhash(blocks_to_bits(blocks, block_width * block_height))
+  end
+
+  def self.calculate_from_path(path, bits = DEFAULT_BITS)
+    calculate(Magick::Image.read(path).first, bits)
+  end
+
+  def self.block_overlaps(index, size, block_size, even)
+    block = index / block_size
+    block_prev = block.to_i
+    if even
+      weight_prev = 1
+      weight_next = 0
+      block_next = block_prev
+    else
+      index_int, index_frac = ((index + 1) % block_size).divmod 1
+      weight_prev = 1 - index_frac
+      weight_next = index_frac
+      block_next = index_int.positive? || (index + 1) == size ? block_prev : block.ceil.to_i
+    end
+    [block_prev, block_next, weight_prev, weight_next]
+  end
+  private_class_method :block_overlaps
+
+  def self.chunk(string, size)
+    string.unpack("a#{size}" * (string.size / size))
+  end
+  private_class_method :chunk
+
+  def self.median(array)
+    sorted = array.sort
+    length = array.length
+    middle = length / 2
+    return sorted[middle] if length.odd?
+
+    (sorted[middle - 1] + sorted[middle]) / 2.0
+  end
+  private_class_method :median
+
+  def self.total_value_rgba(img, cols, px_x, px_y)
+    i = ((px_y * cols * 4) + (px_x * 4))
+    # Set to max value if pixel is transparent
+    return Magick::QuantumRange * 3 if img[i + 3].zero?
+
+    # Sum RGB values
+    img[i] + img[i + 1] + img[i + 2]
+  end
+  private_class_method :total_value_rgba
+
+  def self.total_value_rgb(img, cols, px_x, px_y)
+    i = ((px_y * cols * 3) + (px_x * 3))
+    # Sum RGB values
+    img[i] + img[i + 1] + img[i + 2]
+  end
+  private_class_method :total_value_rgb
+
+  def self.bits_to_hexhash(bits)
+    chunk(bits, 4).sum("") do |chunk|
+      chunk.to_i(2).to_s(16)
+    end
+  end
+  private_class_method :bits_to_hexhash
+
+  def self.blocks_to_bits(blocks, pixels_per_block)
+    # Half of the max total colour value for the block
+    half_block = pixels_per_block * Magick::QuantumRange * 3 / 2.0
+    # Split image into 4 horizontal bands
+    bandsize = blocks.length / 4
+    # Loop over each band
+    blocks.each_slice(bandsize).sum("") do |band|
+      med = median(band)
+      band.sum("") do |block|
+        block > med || ((block - med).abs < 1 && med > half_block) ? "1" : "0"
+      end
+    end
+  end
+  private_class_method :blocks_to_bits
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: blockhash
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Damien Kingsley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.5
+description: This is a perceptual image hash calculation and comparison tool based
+  on the blockhash method. This can be used to match compressed or resized images
+  to each other.
+email:
+- actuallydamo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/blockhash.rb
+- lib/blockhash/version.rb
+homepage: https://github.com/actuallydamo/blockhash-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/actuallydamo/blockhash-ruby
+  source_code_uri: https://github.com/actuallydamo/blockhash-ruby
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- ImageMagick
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: Generate and compare perceptual image hashes using the blockhash method
+test_files: []