image_quality_check 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b5fbfb17831bb894d3890c10197aff1573ca1f6fbdcf0308f5ec1975cfd35cc6
+  data.tar.gz: d5f5fdf1a2cb61f92566b26cc5954582a94116c056004a24323b93984307507d
+SHA512:
+  metadata.gz: 594ca886f91f517ef6b71fda2cbf350cb4c41991434c3071aaad6f9e63d0d48a71fb1acc08a01835f2e927dd9774cb19655a9d63c63b5829b82796f22e6f6304
+  data.tar.gz: 2b20142b04050a37d1b2655f6188ec69ac534f175acdf4234c4c07edc4760f3ec0b675f255afda053f080e836c852f93f69aa8c972441f80a58cabcff254bba4

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+spec/.examples.txt

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in image_quality.gemspec
+gemspec
+
+gem 'pry'
+gem 'rake'
+gem 'rspec'
+gem 'rubocop'
+gem 'solargraph'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Stefan Wienert
+
+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,145 @@
+# ImageQuality
+
+Thin gem wrapper that uses ``imagemagick`` and ``python-opencv`` to help determine image quality.
+
+
+## Installation
+
+System dependencies:
+
+- Have imagemagick installed (Tool uses ``identify``).
+- have python3 + OpenCV installed: Install OpenCV, e.g. on Ubuntu 18.04:
+
+```
+apt-get install python3-pywt python3-opencv
+```
+
+---
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'image_quality'
+```
+
+## Usage
+
+### Direct usage without model integration
+
+```
+result = ImageQualityCheck.analyze(path_to_file)
+
+{
+  blur: {
+    LPScale: 100
+  }
+  face: null,
+  haseSmile: false,
+  width: 836,
+  format: 'jpeg',
+  height: 604,
+  quality: 90,
+  mime_type: 'image/jpeg',
+}
+```
+
+This tool uses a shipped Python executable from https://github.com/pedrofrodenas/blur-Detection-Haar-Wavelet
+
+The ``blur.LPScale`` gives you info if the image is blurry on a scale of 0..100
+
+### DSL for defining rules for Models
+
+**LIMITS**:
+
+- currently only Paperclip attachment is implemented. Feel free to add other get-the-tmpfile adapter to ``ImageQualityCheck::DetermineQuality#read``
+
+---
+
+Create a initializer in your app:
+
+```ruby
+# config/initializers/image_quality.rb
+
+# define your quality rules per attachment:
+ImageQuality.define_rules_for Person, attachment: :photo do
+  # jpeg and png yields 100 score in this segment
+  preferred_formats_rule(jpeg: 100, png: 100)
+
+  # Sizes with w>400 and h>500 will give 100 score,
+  # otherwise linearly between 0 .. 100
+  preferred_size_rule(400, 500)
+  rule "Photo of a person" do |result, on_error|
+    if result[:blur].slice(:face, :hasSmile, :eyes).any?
+      # detector has either detected face, smile or eyes
+      100
+    else
+      on_error.call("No face found")
+      0
+    end
+  end
+
+  rule "Bluriness/Sharpness" do |result, on_error|
+    blur = result[:blur]
+    # overall picture is sharp (0...100)
+    if blur[:LPScale] > 70
+      100
+    else
+      # also including: you could check LPScale for eyes, face only
+      result = (blur[:LPScale] / 80 * 100).round
+      on_error.call("Contrast or focus is not optimal")
+      result
+    end
+  end
+end
+
+ImageQuality.define_rules_for Organisation, attachment: :logo do
+  preferred_formats_rule(png: 100, svg: 100, jpeg: 50, gif: 50)
+  preferred_size_rule(600, 400)
+end
+
+```
+
+Then you can query for the quality rules to evaluate an attachment:
+
+```ruby
+ImageQuality.determine_quality(some_organisation, :logo) do |result|
+```
+
+### Using example Result model
+
+There is an ActiveRecord example model included in this Gem to save the ImageQuality Results to the database. It uses json column so that (modern) mysql/psql are both supported without any conditionals.
+
+Run:
+
+```
+bundle exec rake image_quality_check_engine:install:migrations
+bin/rails db:migrate
+```
+
+Then you can use this class like so (Example):
+
+```ruby
+  # add to initializer:
+  require 'image_quality/model'
+  ImageQuality.determine_quality(some_organisation, :logo) do |result|
+    ImageQualityCheck::Result.create_for_result(some_organisation, column, result)
+  end
+```
+
+You also want to add a has_one relationship to the host models:
+
+```ruby
+class Person < AR
+  has_one :image_quality_check_result, -> { where(attachable_column: :logo) }, as: :attachable, dependent: :destroy, class_name: "ImageQualityCheck::Result"
+end
+```
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/zealot128/image_quality.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "image_quality"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/config/locales/image_quality.de.yml

@@ -0,0 +1,11 @@
+---
+de:
+  image_quality_check:
+    not_found: Kein Anhang/Bild gefunden
+    dsl:
+      no_qualities_defined_for: No qualities defined for [%{klass}, %{attachment}]
+      format: Format
+      format_ist_nutzen_sie: Format ist %{result_format} - Nutzen Sie %{formats_keys_map_upcase_jo}
+      gro_e: Größe
+      gro_e_ist_x_px_achten_sie: Größe ist %{result_width}x%{result_height}px - Achten
+        Sie auf eine Mindestgröße von min. %{expected_width}x%{expected_height}px

data/config/locales/image_quality.en.yml

@@ -0,0 +1,10 @@
+---
+en:
+  image_quality_check:
+    not_found: "No attachment/photo found"
+    dsl:
+      no_qualities_defined_for: No qualities defined for [%{klass}, %{attachment}]
+      format: Format
+      format_ist_nutzen_sie: Format is %{result_format} - please prefer %{formats_keys_map_upcase_jo}
+      gro_e: Image dimension
+      gro_e_ist_x_px_achten_sie: Size is %{result_width}x%{result_height}px - Please use a minimum size of %{expected_width}x%{expected_height}px

data/db/migrate/20201008124025_create_image_quality_checks.rb

@@ -0,0 +1,15 @@
+class CreateImageQualityChecks < ActiveRecord::Migration[5.2]
+  def change
+    create_table :image_quality_check_results do |t|
+      t.string :attachable_type
+      t.string :attachable_id
+      t.string :attachable_column
+      t.json :result
+      t.integer :quality
+
+      t.timestamps
+      t.index [:attachable_type, :attachable_id], name: 'index_image_quality_checks_on_attachable'
+      t.index [:attachable_type, :attachable_id, :attachable_column], unique: true, name: 'index_image_quality_checks_on_all'
+    end
+  end
+end

data/exe/image_quality_blur

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+
+import sys
+import json
+import numpy as np
+import cv2
+
+null = None
+
+img = cv2.imread(sys.argv[1], 0)
+
+clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+img = clahe.apply(img)
+
+face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+faces_detect = face_cascade.detectMultiScale(img, scaleFactor=1.5, minNeighbors=3)
+
+for (x, y, w, h) in faces_detect:
+    # cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2)
+    face = img[y:y + h, x:x + w]
+
+out = {}
+
+if len(faces_detect) > 0:
+    out['face'] = {}
+    local = np.max(cv2.convertScaleAbs(cv2.Laplacian(face,3)))
+    laplace_face = cv2.Laplacian(face, cv2.CV_64F).var()
+    out['face']['FaceBlurScale'] = int(local / 255 * 100)
+    out['face']['FaceBlurLaplaceVar'] = laplace_face
+else:
+    out['face'] = null
+    face = img
+
+
+smile_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_smile.xml')
+smile_detect = smile_cascade.detectMultiScale(face, minNeighbors=40, scaleFactor=1.14)
+
+eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_eye.xml')
+eye_detect = eye_cascade.detectMultiScale(face, minNeighbors=15)
+
+out['hasSmile'] = len(smile_detect) > 0
+
+if len(eye_detect) > 0:
+    for (x, y, w, h) in eye_detect:
+        eye = img[y:y + h, x:x + w]
+    local_laplace = np.max(cv2.convertScaleAbs(cv2.Laplacian(eye, 3)))
+    laplace_var = cv2.Laplacian(eye, cv2.CV_64F).var()
+    out['eyes'] = {
+        'LPScale': int(local_laplace / 255 * 100),
+        'LPVar': laplace_var
+    }
+else:
+    out['eyes'] = null
+
+laplace = cv2.Laplacian(img, cv2.CV_64F).var()
+local_laplace = np.max(cv2.convertScaleAbs(cv2.Laplacian(img, 3)))
+out['LPVar'] = laplace
+out['LPScale'] = (local_laplace / 255 * 100)
+
+print(json.dumps(out))

data/image_quality_check.gemspec

@@ -0,0 +1,28 @@
+require_relative 'lib/image_quality_check/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "image_quality_check"
+  spec.version       = ImageQualityCheck::VERSION
+  spec.authors       = ["Stefan Wienert"]
+  spec.email         = ["info@stefanwienert.de"]
+
+  spec.summary       = %q{image quality}
+  spec.description   = %q{image quality}
+  spec.homepage      = "https://github.com/pludoni/image_quality_check"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.add_runtime_dependency "i18n"
+end

data/lib/image_quality_check.rb

@@ -0,0 +1,61 @@
+require "image_quality_check/version"
+require 'image_quality_check/dsl'
+require 'image_quality_check/determine_quality'
+require 'shellwords'
+require 'json'
+require 'open3'
+
+module ImageQualityCheck
+  extend ImageQualityCheck::DSL
+
+  def self.determine_quality(model, attachment, &block)
+    ImageQualityCheck::DetermineQuality.run(model, attachment, &block)
+  end
+
+  def self.analyze(path_to_image)
+    out = `convert #{Shellwords.escape path_to_image} json:`
+    # image magick gif delay bug invalid json
+    # https://github.com/ImageMagick/ImageMagick/issues/1624
+    out.gsub!(/("delay": "[^"]+")\n/m, "\\1,\n")
+    json = JSON.parse(out)['image']
+    background_is_transparent =
+      json.dig('channelDepth', 'alpha') &&
+      json['channelStatistics']['alpha']['min'] != json['channelStatistics']['alpha']['max']
+    {
+      format: json['format'].downcase,
+      mime_type: json['mimeType'],
+      background_is_transparent: background_is_transparent,
+      width: json.dig('geometry', 'width'),
+      height: json.dig('geometry', 'height'),
+      quality: json['quality'],
+      blur: blur_detect(path_to_image).map { |k, v| [ k.to_sym, v ] }.to_h
+    }
+  end
+
+  def self.blur_detect(path_to_image)
+    script = File.join(File.dirname(__FILE__), '..', 'exe', 'image_quality_blur')
+    out, err, value = Open3.capture3("#{script} #{Shellwords.escape(path_to_image)}")
+    if value.success?
+      JSON.parse(out.gsub('NaN', '0'))
+    else
+      if out[/^\{/]
+        JSON.parse(out)
+      else
+        {
+          error: err.to_s,
+          out: out.to_s
+        }
+      end
+    end
+  end
+end
+
+if defined?(Rails)
+  class ImageQualityCheck::Engine < Rails::Engine
+  end
+else
+  require 'i18n'
+  I18n.load_path << Dir[File.expand_path("config/locales") + "/*.yml"]
+  I18n.default_locale ||= :en
+end
+

data/lib/image_quality_check/determine_quality.rb

@@ -0,0 +1,76 @@
+require 'i18n'
+
+class ImageQualityCheck::DetermineQuality
+  def self.run(model, column_name, tmp_file = nil, &block)
+    new(model, column_name, tmp_file).run(&block)
+  end
+
+  def initialize(model, column_name, tmp_file = nil)
+    @model = model
+    @column_name = column_name
+    @column = model.send(column_name)
+    @messages = []
+    @tmp_file = tmp_file
+  end
+
+  def run(&block)
+    unless @tmp_file
+      @tmp_file = Tempfile.new(['image_quality'])
+      unless read!(@tmp_file)
+        result = {
+          quality: 0,
+          details: {},
+          messages: [{ name: I18n.t('image_quality_check.not_found'), quality: 0 }]
+        }
+        yield(result) if block_given?
+        return result
+      end
+    end
+
+    @analyse_result = ImageQualityCheck.analyze(@tmp_file.path)
+    result = {
+      quality: determine_quality,
+      details: @analyse_result,
+      messages: @messages,
+    }
+    yield(result) if block_given?
+    result
+  end
+
+  private
+
+  def determine_quality
+    qualities = []
+    sum_of_weights = 0
+    ImageQualityCheck.rules_for(@model.class, @column_name).each do |qq|
+      error = nil
+      on_error = ->(msg) { error = msg }
+      result = instance_exec(@analyse_result, on_error, &qq[:block])
+      @messages << {
+        name: qq[:name],
+        quality: result,
+        message: error
+      }
+      if result
+        qualities << result * qq[:weight]
+        sum_of_weights += qq[:weight]
+      end
+    end
+
+    (qualities.sum / sum_of_weights.to_f).round
+  end
+
+  def read!(tmp_file)
+    case @column.class.to_s
+    when "Paperclip::Attachment"
+      if !@column.path || !File.exist?(@column.path)
+        false
+      else
+        FileUtils.cp(@column.path, tmp_file.path)
+        true
+      end
+    else
+      raise NotImplementedError, @column.class
+    end
+  end
+end

data/lib/image_quality_check/dsl.rb

@@ -0,0 +1,56 @@
+require 'i18n'
+# rubocop:disable Style/ClassVars,Metrics/BlockLength
+module ImageQualityCheck::DSL
+  def define_rules_for(klass, attachment:, &block)
+    @rules ||= {}
+    @rules[[klass.to_s, attachment.to_s]] = block
+  end
+
+  def rules_for(klass, attachment)
+    rule = @rules[[klass.to_s, attachment.to_s]]
+    unless rule
+      raise NotImplemented, I18n.t("image_quality_check.dsl.no_qualities_defined_for", klass: (klass), attachment: (attachment))
+    end
+    @current_rule = []
+    class_exec(&rule)
+    @current_rule
+  end
+
+  def rule(name, weight: 1, &block)
+    @current_rule << { name: name, block: block, weight: weight }
+  end
+
+  def preferred_formats_rule(formats, weight: 1)
+    rule I18n.t("image_quality_check.dsl.format"), weight: weight do |result, on_error|
+      final_score = nil
+      formats.each do |f, score|
+        if result[:format].downcase.to_s == f.downcase.to_s
+          final_score ||= score
+        end
+      end
+      final_score ||= 0
+      if final_score < 100
+        message = I18n.t("image_quality_check.dsl.format_ist_nutzen_sie",
+                         result_format: (result[:format]),
+                         formats_keys_map_upcase_jo: (formats.keys.map(&:upcase).join(', ')))
+        on_error.call(message)
+      end
+      final_score
+    end
+  end
+
+  def preferred_size_rule(expected_width, expected_height, weight: 2)
+    rule I18n.t("image_quality_check.dsl.gro_e"), weight: weight do |result, on_error|
+      if result[:width] >= expected_width && result[:height] >= expected_height
+        100
+      else
+        target = expected_width * expected_height
+        current = result[:width] * result[:height]
+        on_error.call(
+          I18n.t("image_quality_check.dsl.gro_e_ist_x_px_achten_sie", result_width: (result[:width]), result_height: (result[:height]), expected_width: (expected_width), expected_height: (expected_height))
+        )
+        [current / target.to_f * 100, 90].min.round
+      end
+    end
+  end
+end

data/lib/image_quality_check/model.rb

@@ -0,0 +1,34 @@
+
+# == Schema Information
+#
+# Table name: image_quality_check_results
+#
+#  id                :bigint(8)        not null, primary key
+#  attachable_column :string(255)
+#  attachable_type   :string(255)
+#  quality           :integer
+#  result            :json
+#  created_at        :datetime         not null
+#  updated_at        :datetime         not null
+#  attachable_id     :string(255)
+#
+# Indexes
+#
+#  index_image_quality_checks_on_all         (attachable_type,attachable_id,attachable_column) UNIQUE
+#  index_image_quality_checks_on_attachable  (attachable_type,attachable_id)
+#
+
+class ImageQualityCheck::Result < ApplicationRecord
+  self.table_name = 'image_quality_check_results'
+  belongs_to :attachable, polymorphic: true
+
+  def self.create_for_result(attachable, column, result)
+    check = ImageQualityCheck::Result.where(attachable: attachable, attachable_column: column).first_or_initialize
+    check.quality = result[:quality]
+    check.result = {
+      details: result[:details],
+      messages: result[:messages],
+    }
+    check.save!
+  end
+end

data/lib/image_quality_check/version.rb

@@ -0,0 +1,3 @@
+module ImageQualityCheck
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: image_quality_check
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Stefan Wienert
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: i18n
+  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'
+description: image quality
+email:
+- info@stefanwienert.de
+executables:
+- image_quality_blur
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- config/locales/image_quality.de.yml
+- config/locales/image_quality.en.yml
+- db/migrate/20201008124025_create_image_quality_checks.rb
+- exe/image_quality_blur
+- image_quality_check.gemspec
+- lib/image_quality_check.rb
+- lib/image_quality_check/determine_quality.rb
+- lib/image_quality_check/dsl.rb
+- lib/image_quality_check/model.rb
+- lib/image_quality_check/version.rb
+homepage: https://github.com/pludoni/image_quality_check
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/pludoni/image_quality_check
+  source_code_uri: https://github.com/pludoni/image_quality_check
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: image quality
+test_files: []