dcthash 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b73e184bb46162ad4bc3de29888ba7b427c5a28ffd8ab3b5a7028f601868c7fd
+  data.tar.gz: a89de0b14f3498f3ca4c6ca94123b44798d998c8a6163130c57ca340d80198d5
+SHA512:
+  metadata.gz: b33b7d04d8441c142d8f65853d29e59fbca08b9cf8cbea499081f1eba228e4b09dae225ebbac3c81f821a1c81c46320dba748d30c514b2521bbe015c33b338d7
+  data.tar.gz: 3ec6099076b8bb4c418b38cae43aab403e5bc8ce7675198314d95d5e050abd6a92a54ffb03fabe65017e59e4b5a09a59c174104ef802925b60ed108a2a8111f1

data/README.md

@@ -0,0 +1,63 @@
+# DCTHash
+
+This is Ruby Gem that can be used to produce and compare perceptual image hashes.
+
+## Installation
+
+### Prerequisites
+
+On Debian/Ubuntu/Mint, you can run:
+```sh
+sudo apt get install libmagickwand-dev
+```
+
+On Arch you can run:
+```sh
+pacman -Sy pkg-config imagemagick
+```
+
+On macOS, you can run:
+```sh
+brew install pkg-config imagemagick
+```
+
+### Gem Install
+
+Install via Bundler
+```sh
+bundle add dcthash
+```
+
+Or install via RubyGems:
+```sh
+gem install dcthash
+```
+
+## Usage
+
+```ruby
+require "dcthash"
+require "rmagick"
+
+image1 = Magick::Image.read("image1.png").first
+image2 = Magick::Image.read("image2.png").first
+
+# Generate image hashes
+hash1 = Dcthash.calculate(image1)
+hash2 = Dcthash.calculate(image2)
+
+# Determine if hashes are similar
+similar = Dcthash.similar?(hash1, hash2, threshold = 13)
+
+# Calculate difference between two hashes
+distance = Dcthash.distance(hash1, hash2)
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/actuallydamo/dcthash.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/dcthash/version.rb

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

data/lib/dcthash.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative "dcthash/version"
+
+# DCT Hash Module
+module Dcthash
+  EDGE_SIZE = 32 # Resize each edge of image to this
+  SUBSAMPLE_START = 1 # Grab subsample from this point
+  SUBSAMPLE_END = 8 # Grab subsample to this point
+
+  # Calculate the distance between two hashes
+  # @param hash1 [String] The first hash
+  # @param hash2 [String] The second hash
+  # @return [Integer] hamming distance between hashes
+  def self.distance(hash1, hash2)
+    (hash1.to_i(16) ^ hash2.to_i(16)).to_s(2).count("1")
+  end
+
+  # Determine if two hashes are similar
+  # @param hash1 [String] The first hash
+  # @param hash2 [String] The second hash
+  # @param threshold [Integer] (optional) The threshold for similarity
+  # @return [Boolean] true if hashes are similar
+  def self.similar?(hash1, hash2, threshold = 13)
+    distance(hash1, hash2) < threshold
+  end
+
+  # Calculate the hash of an image
+  # @param image [Magick::Image] The image to hash
+  # @return [String] the hash of the image
+  def self.calculate(image)
+    image.resize!(EDGE_SIZE, EDGE_SIZE, Magick::PointFilter)
+    image = image.quantize(256, Magick::GRAYColorspace, Magick::NoDitherMethod)
+
+    intensity_matrix = image.export_pixels(0, 0, EDGE_SIZE, EDGE_SIZE, "I").each_slice(EDGE_SIZE).to_a
+
+    dct_result = dct_2d(intensity_matrix)
+    # @type var sub_matrix: Array[Float]
+    sub_matrix = ((dct_result[SUBSAMPLE_START..SUBSAMPLE_END] || [])
+    .transpose[SUBSAMPLE_START..SUBSAMPLE_END] || []).flatten
+
+    median = median(sub_matrix)
+    result = sub_matrix.map { |px| px < median ? 1 : 0 }
+    result.join.to_i(2).to_s(16)
+  end
+
+  # Find the median from an even length array of numbers
+  # @param array [Array<Float>] The array of numbers
+  # @return [Float] the value of the median
+  def self.median(array)
+    sorted = array.sort
+    length = array.length
+    middle = length / 2
+    # We only use even length arrays so the following line is not needed
+    # return sorted[middle] if length.odd?
+
+    (sorted[middle - 1] + sorted[middle]).fdiv(2)
+  end
+  private_class_method :median
+
+  # Calculate the DCT of a vector
+  # Adapted from https://www.nayuki.io/page/fast-discrete-cosine-transform-algorithms
+  # Copyright (c) 2020 Project Nayuki. (MIT License)
+  # @param vector [Array<Numeric>] the vector to transform
+  # @return [Array<Float>] the discrete cosine transform of the vector
+  def self.dct(vector)
+    vector_size = vector.size
+    return [Float(vector[0])] if vector_size == 1
+
+    half = vector_size / 2
+    alpha = (0...half).map { |i| vector[i] + (vector[-(i + 1)]) }
+    beta = (0...half).map do |i|
+      (vector[i] - (vector[-(i + 1)])).fdiv(Math.cos(((i + 0.5) * Math::PI).fdiv(vector_size)) * 2)
+    end
+    alpha = dct(alpha)
+    beta = dct(beta)
+    result = (0...half - 1).flat_map do |i|
+      [alpha[i], beta[i] + beta[i + 1]]
+    end
+    result.push(alpha[-1])
+    result.push(beta[-1])
+  end
+  private_class_method :dct
+
+  # Calculate the 2D DCT of a matrix
+  # @param input [Array<Array<Numeric>>] the matrix to calculate the 2D DCT of
+  # @return [Array<Array<Float>>] the DCT of the matrix
+  def self.dct_2d(input)
+    input.map { |row| dct(row) }
+         .transpose
+         .map { |col| dct(col) }
+  end
+  private_class_method :dct_2d
+end

data/sig/dcthash.rbs

@@ -0,0 +1,18 @@
+module Dcthash
+  VERSION: String
+  EDGE_SIZE: Integer
+  SUBSAMPLE_START: Integer
+  SUBSAMPLE_END: Integer
+
+  def self.distance: (String, String) -> Integer
+
+  def self.similar?: (String, String, ?Integer) -> bool
+
+  def self.calculate: (Magick::Image) -> String
+
+  def self.median: (Array[Float]) -> Float
+
+  def self.dct: (Array[Numeric]) -> Array[Float]
+
+  def self.dct_2d: (Array[Array[Numeric]]) -> Array[Array[Float]]
+end

data/sig/rmagick.rbs

@@ -0,0 +1,18 @@
+module Magick
+  class Enum
+  end
+  class FilterType < Enum
+  end
+  PointFilter: FilterType
+  class ColorspaceType < Enum
+  end
+  GRAYColorspace: ColorspaceType
+  class DitherMethod < Enum
+  end
+  NoDitherMethod: DitherMethod
+  class Image
+    def quantize: (?Numeric, ?Magick::ColorspaceType, ?Magick::DitherMethod, ?Integer, ?bool) -> Magick::Image
+    def resize!: ((Float | Integer), ?(Float | Integer), ?Magick::FilterType, ?Float) -> Magick::Image
+    def export_pixels: (?Numeric, ?Numeric, ?Numeric, ?Numeric, ?String) -> Array[Numeric]
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: dcthash
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Damien Kingsley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-07-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: This is a perceptual image hash calculation and comparison tool. This
+  can be used to match compressed or resized images to each other.
+email:
+- actuallydamo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/dcthash.rb
+- lib/dcthash/version.rb
+- sig/dcthash.rbs
+- sig/rmagick.rbs
+homepage: https://github.com/actuallydamo/dcthash
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/actuallydamo/dcthash
+  source_code_uri: https://github.com/actuallydamo/dcthash
+  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: []
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: Generate and compare perceptual image hashes
+test_files: []