image_compare 1.0.0.pre.dev

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a67b91873ee2ca3ec939803ef3ff7c7e116ce75e48d4643340aae67f48c59225
+  data.tar.gz: 2795771468140989921e1ec9afffa2f9616f5363df7106e050ebcb36871659b0
+SHA512:
+  metadata.gz: 39a0d7d0bc330345bc4a9624bbbd721f7206db5d5c0d5900bfaa78bb0eec90dd9c03598d683c7f165a78549a8d311edaa7e206b5773abe96672479b25a322851
+  data.tar.gz: 3fc93372828b8354867e63ac3e80cd2998fdd025ef9e3601a239d952f7ec0bfbdff3cd148bd03c4feb1a2c9cddf0be73c39da65ad55276639f3ac392886af1fa

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Change log
+
+## main
+- Add Color mode to generate "normal" diff images ([@gsguma][], [@cristianofmc][])
+
+[@gsguma]: https://github.com/gsguma
+[@cristianofmc]: https://github.com/cristianofmc

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 instantink
+
+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,119 @@
+[![Gem Version](https://badge.fury.io/rb/image_compare.svg)](https://rubygems.org/gems/image_compare)
+[![Build](https://github.com/instantink/image_compare/workflows/Build/badge.svg)](https://github.com/instantink/image_compare/actions)
+
+# ImageCompare
+
+Compare PNG images in pure Ruby (uses [ChunkyPNG](https://github.com/wvanbergen/chunky_png)) using different algorithms.
+This is an utility library for image regression testing.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'image_compare'
+```
+
+Or adding to your project:
+
+```ruby
+# my-cool-gem.gemspec
+Gem::Specification.new do |spec|
+  # ...
+  spec.add_dependency 'image_compare'
+  # ...
+end
+```
+
+Additionally, you may want to install [oily_png](https://github.com/wvanbergen/oily_png) to improve performance when using MRI. Just install it globally or add to your Gemfile.
+
+## Modes
+
+ImageCompare supports different ways (_modes_) of comparing images.
+
+Source images used in examples:
+
+<img src='https://raw.githubusercontent.com/instantink/image_compare/master/spec/fixtures/a.png' width='300' />
+<img src='https://raw.githubusercontent.com/instantink/image_compare/master/spec/fixtures/b.png' width='300' />
+
+### Base (RGB) mode
+
+Compare pixels by values, resulting score is a ratio of unequal pixels.
+Resulting diff represents per-channel difference.
+
+<img src='https://raw.githubusercontent.com/instantink/image_compare/master/spec/fixtures/rgb_diff.png' width='300' />
+
+### Grayscale mode
+
+Compare pixels as grayscale (by brightness and alpha), resulting score is a ratio of unequal pixels (with respect to provided tolerance).
+
+Resulting diff contains grayscale version of the first image with different pixels highlighted in red and red bounding box.
+
+<img src='https://raw.githubusercontent.com/instantink/image_compare/master/spec/fixtures/grayscale_diff.png' width='300' />
+
+### Delta
+
+Compare pixels using [Delta E](https://en.wikipedia.org/wiki/Color_difference) distance.
+Resulting diff contains grayscale version of the first image with different pixels highlighted in red (with respect to diff score).
+
+<img src='https://raw.githubusercontent.com/instantink/image_compare/master/spec/fixtures/delta_diff.png' width='300' />
+
+## Usage
+
+```ruby
+# create new matcher with default threshold equals to 0
+# and base (RGB) mode
+cmp = ImageCompare::Matcher.new
+cmp.mode #=> ImageCompare::Modes::RGB
+
+# create matcher with specific threshold
+cmp = ImageCompare::Matcher.new threshold: 0.05
+cmp.threshold #=> 0.05
+
+# or with a lower threshold (in case you want to test that there is some difference)
+cmp = ImageCompare::Matcher.new lower_threshold: 0.01
+cmp.lower_threshold #=> 0.01
+
+# create zero-tolerance grayscale matcher
+cmp = ImageCompare::Matcher.new mode: :grayscale, tolerance: 0
+cmp.mode #=> ImageCompare::Modes::Grayscale
+
+res = cmp.compare(path_1, path_2)
+res #=> ImageCompare::Result
+res.match? #=> true
+res.score #=> 0.0
+
+# Return diff image object
+res.difference_image #=> ImageCompare::Image
+res.difference_image.save(new_path)
+
+# without explicit matcher
+res = ImageCompare.compare(path_1, path_2, options)
+
+# equals to
+res = ImageCompare::Matcher.new(options).compare(path_1, path_2)
+```
+
+## Excluding rectangle
+
+<img src='https://raw.githubusercontent.com/instantink/image_compare/master/spec/fixtures/a.png' width='300' />
+<img src='https://raw.githubusercontent.com/instantink/image_compare/master/spec/fixtures/a1.png' width='300' />
+
+You can exclude rectangle from comparing by passing `:exclude_rect` to `compare`.
+E.g., if `path_1` and `path_2` contain images above
+```ruby
+ImageCompare.compare(path_1, path_2, exclude_rect: [200, 150, 275, 200]).match? # => true
+```
+`[200, 150, 275, 200]` is array of two vertices of rectangle -- (200, 150) is left-top vertex and (275, 200) is right-bottom.
+
+## Including rectangle
+
+You can set bounds of comparing by passing `:include_rect` to `compare` with array similar to previous example
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/instantink/image_compare.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'image_compare'
+require 'pry'
+
+Pry.start

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/lib/image_compare/color_methods.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'chunky_png'
+
+begin
+  require 'oily_png' unless RUBY_PLATFORM == 'java'
+rescue LoadError => _e
+  nil
+end
+
+module ImageCompare
+  module ColorMethods
+    include ChunkyPNG::Color
+
+    def brightness(a)
+      0.3 * r(a) + 0.59 * g(a) + 0.11 * b(a)
+    end
+
+    def red
+      rgb(255, 0, 0)
+    end
+
+    def green
+      rgb(0, 255, 0)
+    end
+
+    def blue
+      rgb(0, 0, 255)
+    end
+
+    def yellow
+      rgb(255, 255, 51)
+    end
+
+    def orange
+      rgb(255, 128, 0)
+    end
+
+    def transparent
+      rgba(255, 255, 255, 255)
+    end
+  end
+end

data/lib/image_compare/image.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'image_compare/color_methods'
+
+module ImageCompare
+  class Image < ChunkyPNG::Image
+    include ColorMethods
+
+    def each_pixel
+      height.times do |y|
+        current_row = row(y) || []
+        current_row.each_with_index do |pixel, x|
+          yield(pixel, x, y)
+        end
+      end
+    end
+
+    def compare_each_pixel(image, area: nil)
+      area = bounding_rect if area.nil?
+      (area.top..area.bot).each do |y|
+        current_row = row(y) || []
+        range = (area.left..area.right)
+        next if image.row(y).slice(range) == current_row.slice(range)
+        (area.left..area.right).each do |x|
+          yield(self[x, y], image[x, y], x, y)
+        end
+      end
+    end
+
+    def to_grayscale
+      each_pixel do |pixel, x, y|
+        self[x, y] = grayscale(brightness(pixel).round)
+      end
+      self
+    end
+
+    def with_alpha(value)
+      each_pixel do |pixel, x, y|
+        self[x, y] = rgba(r(pixel), g(pixel), b(pixel), value)
+      end
+      self
+    end
+
+    def sizes_match?(image)
+      [width, height] == [image.width, image.height]
+    end
+
+    def inspect
+      "Image:#{object_id}<#{width}x#{height}>"
+    end
+
+    def highlight_rectangle(rect, color = :red)
+      raise ArgumentError, "Undefined color: #{color}" unless respond_to?(color)
+      return self if rect.nil?
+      rect(*rect.bounds, send(color))
+      self
+    end
+
+    def bounding_rect
+      Rectangle.new(0, 0, width - 1, height - 1)
+    end
+  end
+end

data/lib/image_compare/matcher.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ImageCompare
+  class Matcher
+    require 'image_compare/image'
+    require 'image_compare/result'
+    require 'image_compare/modes'
+
+    MODES = {
+      rgb: 'RGB',
+      delta: 'Delta',
+      grayscale: 'Grayscale',
+      color: 'Color'
+    }.freeze
+
+    attr_reader :mode
+
+    def initialize(**options)
+      mode_type = options.delete(:mode) || :rgb
+      raise ArgumentError, "Undefined mode: #{mode_type}" unless MODES.key?(mode_type)
+      @mode = Modes.const_get(MODES[mode_type]).new(**options)
+    end
+
+    def compare(a, b)
+      a = Image.from_file(a) unless a.is_a?(Image)
+      b = Image.from_file(b) unless b.is_a?(Image)
+
+      unless a.sizes_match?(b)
+        raise SizesMismatchError,
+              "Size mismatch: first image size: #{a.width}x#{a.height}, second image size: #{b.width}x#{b.height}"
+      end
+
+      image_area = Rectangle.new(0, 0, a.width - 1, a.height - 1)
+
+      unless mode.exclude_rect.nil?
+        unless image_area.contains?(mode.exclude_rect)
+          raise ArgumentError, 'Bounds must be in image'
+        end
+      end
+
+      unless mode.include_rect.nil?
+        unless image_area.contains?(mode.include_rect)
+          raise ArgumentError, 'Bounds must be in image'
+        end
+        unless mode.exclude_rect.nil?
+          unless mode.include_rect.contains?(mode.exclude_rect)
+            raise ArgumentError, 'Included area must contain excluded'
+          end
+        end
+      end
+
+      mode.compare(a, b)
+    end
+  end
+end

data/lib/image_compare/modes/base.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ImageCompare
+  module Modes
+    class Base
+      require 'image_compare/rectangle'
+      include ColorMethods
+
+      attr_reader :result, :threshold, :lower_threshold, :bounds, :exclude_rect, :include_rect
+
+      def initialize(threshold: 0.0, lower_threshold: 0.0, exclude_rect: nil, include_rect: nil)
+        @include_rect = Rectangle.new(*include_rect) unless include_rect.nil?
+        @exclude_rect = Rectangle.new(*exclude_rect) unless exclude_rect.nil?
+        @threshold = threshold
+        @lower_threshold = lower_threshold
+        @result = Result.new(self, threshold: threshold, lower_threshold: lower_threshold)
+      end
+
+      def compare(a, b)
+        result.image = a
+        @include_rect ||= a.bounding_rect
+        @bounds = Rectangle.new(*include_rect.bounds)
+
+        b.compare_each_pixel(a, area: include_rect) do |b_pixel, a_pixel, x, y|
+          next if pixels_equal?(b_pixel, a_pixel)
+          next if !exclude_rect.nil? && exclude_rect.contains_point?(x, y)
+          update_result(b_pixel, a_pixel, x, y)
+        end
+
+        result.score = score
+        result
+      end
+
+      def diff(bg, diff)
+        diff_image = background(bg).highlight_rectangle(exclude_rect, :blue)
+        diff.each do |pixels_pair|
+          pixels_diff(diff_image, *pixels_pair)
+        end
+        create_diff_image(bg, diff_image)
+          .highlight_rectangle(bounds)
+          .highlight_rectangle(include_rect, :green)
+      end
+
+      def score
+        result.diff.length.to_f / area
+      end
+
+      def update_result(*_args, x, y)
+        update_bounds(x, y)
+      end
+
+      def update_bounds(x, y)
+        bounds.left = [x, bounds.left].max
+        bounds.top = [y, bounds.top].max
+        bounds.right = [x, bounds.right].min
+        bounds.bot = [y, bounds.bot].min
+      end
+
+      def area
+        area = include_rect.area
+        return area if exclude_rect.nil?
+        area - exclude_rect.area
+      end
+    end
+  end
+end

data/lib/image_compare/modes/color.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ImageCompare
+  module Modes
+    require 'image_compare/modes/base'
+
+    class Color < Base
+      include ColorMethods
+
+      DEFAULT_TOLERANCE = 16
+
+      attr_reader :tolerance
+
+      def initialize(**options)
+        @tolerance = options.delete(:tolerance) || DEFAULT_TOLERANCE
+        super(**options)
+      end
+
+      def diff(bg, diff)
+        diff_image = bg.highlight_rectangle(exclude_rect, :blue)
+
+        if area_in_exclude_rect?
+          diff_image
+        else
+          diff_image.highlight_rectangle(bounds)
+        end
+      end
+
+      def area_in_exclude_rect?
+        return false if exclude_rect.nil?
+
+        diff_area = {
+          left: bounds.bounds[0],
+          top: bounds.bounds[1],
+          right: bounds.bounds[2],
+          bot:  bounds.bounds[3]
+        }
+
+        exclude_area = {
+          left: exclude_rect.bounds[0],
+          top: exclude_rect.bounds[1],
+          right: exclude_rect.bounds[2],
+          bot:  exclude_rect.bounds[3]
+        }
+
+        diff_area[:left] <= exclude_area[:left] &&
+        diff_area[:top] <= exclude_area[:top] &&
+        diff_area[:right] >= exclude_area[:right] &&
+        diff_area[:bot] >= exclude_area[:bot]
+      end
+
+      def pixels_equal?(a, b)
+        alpha = color_similar?(a(a), a(b))
+        brightness = color_similar?(brightness(a), brightness(b))
+        brightness && alpha
+      end
+
+      def update_result(a, b, x, y)
+        super
+        @result.diff << [a, b, x, y]
+      end
+
+      def color_similar?(a, b)
+        d = (a - b).abs
+        d <= tolerance
+      end
+    end
+  end
+end

data/lib/image_compare/modes/delta.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ImageCompare
+  module Modes
+    require 'image_compare/modes/base'
+
+    class Delta < Base
+      attr_reader :tolerance
+
+      def initialize(**options)
+        @tolerance = options.delete(:tolerance) || 0.01
+        @delta_score = 0.0
+        super(**options)
+      end
+
+      private
+
+      def pixels_equal?(a, b)
+        a == b
+      end
+
+      def update_result(a, b, x, y)
+        d = euclid(a, b) / (MAX * Math.sqrt(3))
+        return if d <= tolerance
+        @result.diff << [a, b, x, y, d]
+        @delta_score += d
+        super
+      end
+
+      def background(bg)
+        Image.new(bg.width, bg.height, WHITE).with_alpha(0)
+      end
+
+      def euclid(a, b)
+        Math.sqrt(
+          (r(a) - r(b))**2 +
+          (g(a) - g(b))**2 +
+          (b(a) - b(b))**2
+        )
+      end
+
+      def create_diff_image(bg, diff_image)
+        bg.to_grayscale.compose!(diff_image, 0, 0)
+      end
+
+      def pixels_diff(d, *_args, x, y, a)
+        d[x, y] = rgba(MAX, 0, 0, (a * MAX).round)
+      end
+
+      def score
+        @delta_score / area
+      end
+    end
+  end
+end

data/lib/image_compare/modes/grayscale.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ImageCompare
+  module Modes
+    require 'image_compare/modes/base'
+
+    class Grayscale < Base
+      DEFAULT_TOLERANCE = 16
+
+      attr_reader :tolerance
+
+      def initialize(**options)
+        @tolerance = options.delete(:tolerance) || DEFAULT_TOLERANCE
+        super(**options)
+      end
+
+      def pixels_equal?(a, b)
+        alpha = color_similar?(a(a), a(b))
+        brightness = color_similar?(brightness(a), brightness(b))
+        brightness && alpha
+      end
+
+      def update_result(a, b, x, y)
+        super
+        @result.diff << [a, b, x, y]
+      end
+
+      def background(bg)
+        bg.to_grayscale
+      end
+
+      def pixels_diff(d, _a, _b, x, y)
+        d[x, y] = rgb(255, 0, 0)
+      end
+
+      def create_diff_image(_bg, diff_image)
+        diff_image
+      end
+
+      def color_similar?(a, b)
+        d = (a - b).abs
+        d <= tolerance
+      end
+    end
+  end
+end

data/lib/image_compare/modes/rgb.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ImageCompare
+  module Modes
+    require 'image_compare/modes/base'
+
+    class RGB < Base
+      def pixels_equal?(a, b)
+        a == b
+      end
+
+      def update_result(a, b, x, y)
+        super
+        @result.diff << [a, b, x, y]
+      end
+
+      def background(bg)
+        Image.new(bg.width, bg.height, BLACK)
+      end
+
+      def create_diff_image(_bg, diff_image)
+        diff_image
+      end
+
+      def pixels_diff(d, a, b, x, y)
+        d[x, y] = rgb(
+          (r(a) - r(b)).abs,
+          (g(a) - g(b)).abs,
+          (b(a) - b(b)).abs
+        )
+      end
+    end
+  end
+end

data/lib/image_compare/modes.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ImageCompare
+  module Modes
+    require 'image_compare/modes/rgb'
+    require 'image_compare/modes/grayscale'
+    require 'image_compare/modes/delta'
+    require 'image_compare/modes/color'
+  end
+end

data/lib/image_compare/rectangle.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ImageCompare
+  class Rectangle
+    attr_accessor :left, :top, :right, :bot
+
+    def initialize(l, t, r, b)
+      @left = l
+      @top = t
+      @right = r
+      @bot = b
+    end
+
+    def area
+      (right - left + 1) * (bot - top + 1)
+    end
+
+    def contains?(rect)
+      (left <= rect.left) &&
+        (right >= rect.right) &&
+        (top <= rect.top) &&
+        (bot >= rect.bot)
+    end
+
+    def bounds
+      [left, top, right, bot]
+    end
+
+    def contains_point?(x, y)
+      x.between?(left, right) && y.between?(top, bot)
+    end
+  end
+end

data/lib/image_compare/result.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ImageCompare
+  class Result
+    attr_accessor :score, :image
+    attr_reader :diff, :mode, :threshold, :lower_threshold
+
+    def initialize(mode, threshold:, lower_threshold:)
+      @score = 0.0
+      @diff = []
+      @threshold = threshold
+      @lower_threshold = lower_threshold
+      @mode = mode
+    end
+
+    def difference_image
+      @diff_image ||= mode.diff(image, diff)
+    end
+
+    def match?
+      score <= threshold && score >= lower_threshold
+    end
+  end
+end

data/lib/image_compare/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ImageCompare
+  VERSION = '1.0.0-dev'
+end

data/lib/image_compare.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'image_compare/version'
+
+module ImageCompare
+  class SizesMismatchError < StandardError
+  end
+
+  require 'image_compare/matcher'
+  require 'image_compare/color_methods'
+
+  def self.compare(path_a, path_b, **options)
+    Matcher.new(**options).compare(path_a, path_b)
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: image_compare
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre.dev
+platform: ruby
+authors:
+- cristianofmc
+- gsguma
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-03-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chunky_png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.9'
+description: Image comparison lib built on top of ChunkyPNG
+email:
+- cristiano.fmc@hotmail.com
+- giltonguma@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- bin/console
+- bin/setup
+- lib/image_compare.rb
+- lib/image_compare/color_methods.rb
+- lib/image_compare/image.rb
+- lib/image_compare/matcher.rb
+- lib/image_compare/modes.rb
+- lib/image_compare/modes/base.rb
+- lib/image_compare/modes/color.rb
+- lib/image_compare/modes/delta.rb
+- lib/image_compare/modes/grayscale.rb
+- lib/image_compare/modes/rgb.rb
+- lib/image_compare/rectangle.rb
+- lib/image_compare/result.rb
+- lib/image_compare/version.rb
+homepage: https://github.com/instantink/image_compare
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/instantink/image_compare/issues
+  changelog_uri: https://github.com/instantink/image_compare/blob/master/CHANGELOG.md
+  documentation_uri: https://github.com/instantink/image_compare
+  homepage_uri: https://github.com/instantink/image_compare
+  source_code_uri: https://github.com/instantink/image_compare
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.4.1
+signing_key: 
+specification_version: 4
+summary: Image comparison lib
+test_files: []