color_decomposition 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3a3e2459586c1089713d950211118369334dd380
+  data.tar.gz: 7febaebbff5ed6b25d45fff3b0a724d29ecf984a
+SHA512:
+  metadata.gz: 786af0e7a8fb9d336f4be8aec8f6a873607ac98d150d5111576bf0f41691355f823f876dcd9b0e0793c44a1f49698c7f5b1a4315efe9019d2003b9cfa956a6e7
+  data.tar.gz: b5cf8c04d802782c02c262b1eb278e3453955503d5c2d684e7306b57c390d48cbcda6fa44dd8ddf2ea7663d19b0c5c6c09f52d082b84e6ef671a847300e296cc

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+Gemfile.lock

data/.rubocop.yml

@@ -0,0 +1,10 @@
+AllCops:
+  TargetRubyVersion: 2.4
+Style/Documentation:
+  Enabled: false
+Style/FrozenStringLiteralComment:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Jonas Bleyl
+
+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,89 @@
+# Color decomposition
+
+<img align="left" hspace="20" src="http://i.imgur.com/PZpp3g5.gif" width="120">
+
+A quadtree color decomposition algorithm that uses the CIELAB color space and the
+CIEDE2000 color difference formula.
+
+The generated quadtree structure contains the leaves that represent the highest node
+levels containing a visually similar color for a given area.
+
+## Installation
+
+This gem requires an installation of
+[ImageMagick](https://legacy.imagemagick.org/script/download.php) `version 6`. Once this
+is done you can install the gem:
+
+``` bash
+gem install color_decomposition
+```
+
+## Usage
+
+Generating the actual quadtree simply requires calling the `quadtree` method. This
+method takes 2 parameters. The first being the path to the image and the second being
+the color similarity level that the CIEDE2000 formula should use. The higher this value,
+the more color loss will be allowed. This will allow the creation of larger leaf nodes
+at the cost of color accuracy.
+
+When comparing 2 colors, a CIEDE2000 value of `<= 1` will generally mean that the
+difference between them will not be perceivable to the human eye.
+
+``` ruby
+require 'color_decomposition'
+
+quadtree = ColorDecomposition.quadtree('ruby.png', 1)
+```
+
+This will return a quadtree object with a nested structure as shown below. Only leaf
+nodes will have the RGB and CIELAB color values set.
+
+``` ruby
+#<ColorDecomposition::Node:0x007fb707196f98
+ @child_nodes=
+  [#<ColorDecomposition::Node:0x007fb707196ef8
+    @child_nodes=nil,
+    @lab={:l=>0.0, :a=>0.0, :b=>0.0},
+    @rect={:left=>0, :top=>0, :right=>32, :bottom=>32},
+    @rgb={:r=>0, :g=>0, :b=>0}>,
+   #<ColorDecomposition::Node:0x007fb707196e80
+    @child_nodes=nil,
+    @lab={:l=>100.0, :a=>0.00526049995830391, :b=>-0.010408184525267927},
+    @rect={:left=>32, :top=>0, :right=>64, :bottom=>32},
+    @rgb={:r=>255, :g=>255, :b=>255}>,
+   #<ColorDecomposition::Node:0x007fb707196e30
+    @child_nodes=nil,
+    @lab={:l=>100.0, :a=>0.00526049995830391, :b=>-0.010408184525267927},
+    @rect={:left=>0, :top=>32, :right=>32, :bottom=>64},
+    @rgb={:r=>255, :g=>255, :b=>255}>,
+   #<ColorDecomposition::Node:0x007fb707196de0
+    @child_nodes=nil,
+    @lab={:l=>100.0, :a=>0.00526049995830391, :b=>-0.010408184525267927},
+    @rect={:left=>32, :top=>32, :right=>64, :bottom=>64},
+    @rgb={:r=>255, :g=>255, :b=>255}>],
+ @lab=nil,
+ @rect={:left=>0, :top=>0, :right=>64, :bottom=>64},
+ @rgb=nil>
+```
+
+The color conversions and CIEDE2000 calculation can also be used on their own.
+
+``` ruby
+require 'color_decomposition'
+
+include ColorDecomposition
+
+color1 = Color.new({r: 255, g: 120, b: 60})
+puts color1.xyz # {:x=>48.77208180663368, :y=>35.01918603060906, :z=>8.46377233268254}
+puts color1.lab # {:l=>65.76360001472788, :a=>47.86642591164642, :b=>55.61626679147632}
+
+color2 = Color.new({r: 80, g: 49, b: 220})
+puts Comparator.ciede2000(color1.lab, color2.lab) # 57.24131929494836
+```
+
+
+## Resources
+
+* [Color space conversions paper.](http://sites.biology.duke.edu/johnsenlab/pdfs/tech/colorconversion.pdf)
+* [sRGB to CIEXYZ transformation values and D65 standard.](http://web.archive.org/web/20110722134652/http://www.colour.org/tc8-05/Docs/colorspace/61966-2-1.pdf)
+* [CIEDE2000 color-difference formula paper and test data.](http://www.ece.rochester.edu/~gsharma/ciede2000)

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake/testtask'
+
+task default: %w[test]
+
+Rake::TestTask.new(:test) do |t|
+  t.libs = ['lib']
+  t.warning = true
+  t.verbose = true
+  t.test_files = FileList['test/*_test.rb']
+end

data/color_decomposition.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'color_decomposition/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'color_decomposition'
+  spec.version       = ColorDecomposition::VERSION
+  spec.authors       = ['Jonas Bleyl']
+  spec.summary       = 'Quadtree decomposition of images by color.'
+  spec.description   = 'Create a quadtree by decomposing images by color using CIELAB.'
+  spec.homepage      = 'https://github.com/jonasbleyl/color-decomposition'
+  spec.license       = 'MIT'
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test)/})
+  end
+  spec.required_ruby_version = '~> 2.4'
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'bundler', '~> 1.13'
+  spec.add_development_dependency 'test-unit', '~> 3.1'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_dependency 'rmagick', '~> 2.16'
+end

data/lib/color_decomposition/color/color.rb

@@ -0,0 +1,59 @@
+require 'matrix'
+
+module ColorDecomposition
+  class Color
+    attr_reader :rgb
+
+    def initialize(rgb)
+      @rgb = rgb
+    end
+
+    def xyz
+      r = xyz_channel(@rgb[:r] / 255.0)
+      g = xyz_channel(@rgb[:g] / 255.0)
+      b = xyz_channel(@rgb[:b] / 255.0)
+
+      # sRGB D65 illuminant and 2 degrees observer values
+      s = Matrix[[0.4124, 0.3576, 0.1805],
+                 [0.2126, 0.7152, 0.0722],
+                 [0.0193, 0.1192, 0.9505]]
+
+      xyz = s * Matrix[[r], [g], [b]] * 100
+      { x: xyz[0, 0], y: xyz[1, 0], z: xyz[2, 0] }
+    end
+
+    def lab
+      xyz_to_lab(xyz)
+    end
+
+    private
+
+    def xyz_to_lab(xyz)
+      # CIEXYZ white point values (D65)
+      x = lab_channel(xyz[:x] / 95.047)
+      y = lab_channel(xyz[:y] / 100.000)
+      z = lab_channel(xyz[:z] / 108.883)
+
+      l = 116 * y - 16
+      a = 500 * (x - y)
+      b = 200 * (y - z)
+      { l: l.clamp(0, 100), a: a, b: b }
+    end
+
+    def xyz_channel(color)
+      if color > 0.04045
+        ((color + 0.055) / 1.055)**2.4
+      else
+        color / 12.92
+      end
+    end
+
+    def lab_channel(color)
+      if color > 0.008856
+        color**(1.0 / 3)
+      else
+        7.787 * color + 16 / 116.0
+      end
+    end
+  end
+end

data/lib/color_decomposition/color/comparator.rb

@@ -0,0 +1,88 @@
+module ColorDecomposition
+  module Comparator
+    extend self
+
+    def ciede2000(lab1, lab2)
+      lch1, lch2 = to_lch(lab1, lab2)
+
+      l_bar = (lch1[:l] + lch2[:l]) / 2
+      c_bar = (lch1[:c] + lch2[:c]) / 2
+      h_bar = mean_hue(lch1, lch2)
+
+      l_delta = lch2[:l] - lch1[:l]
+      c_delta = lch2[:c] - lch1[:c]
+      h_delta = hue_angle(lch1, lch2)
+      o_delta = 30 * Math.exp(-((h_bar - 275) / 25)**2)
+
+      t = 1 - 0.17 * Math.cos(radians(h_bar - 30)) +
+          0.24 * Math.cos(radians(2 * h_bar)) +
+          0.32 * Math.cos(radians(3 * h_bar + 6)) -
+          0.20 * Math.cos(radians(4 * h_bar - 63))
+
+      rc = 2 * Math.sqrt(c_bar**7 / (c_bar**7 + 25**7))
+      sl = 1 + 0.015 * (l_bar - 50)**2 / Math.sqrt(20 + (l_bar - 50)**2)
+      sc = 1 + 0.045 * c_bar
+      sh = 1 + 0.015 * c_bar * t
+      rt = -Math.sin(radians(2 * o_delta)) * rc
+
+      Math.sqrt((l_delta / sl)**2 + (c_delta / sc)**2 + (h_delta / sh)**2 +
+                rt * (c_delta / sc) * (h_delta / sh)).clamp(0, 100)
+    end
+
+    private
+
+    def to_lch(lab1, lab2)
+      c1_star = Math.sqrt(lab1[:a]**2 + lab1[:b]**2)
+      c2_star = Math.sqrt(lab2[:a]**2 + lab2[:b]**2)
+      c_bar_star = (c1_star + c2_star) / 2
+
+      g = 0.5 * (1 - Math.sqrt(c_bar_star**7 / (c_bar_star**7 + 25**7)))
+      [{ l: lab1[:l] }.merge(modified_hue(lab1, g)),
+       { l: lab2[:l] }.merge(modified_hue(lab2, g))]
+    end
+
+    def modified_hue(lab, g)
+      a = (1 + g) * lab[:a]
+      c = Math.sqrt(a**2 + lab[:b]**2)
+
+      h = lab[:b] != 0 || a != 0 ? degrees(Math.atan2(lab[:b], a)) : 0
+      h += 360 if h.negative?
+      { c: c, h: h }
+    end
+
+    def hue_angle(lch1, lch2)
+      h_diff = lch2[:h] - lch1[:h]
+      h = if (lch1[:c] * lch2[:c]).zero?
+            0
+          elsif h_diff.abs <= 180
+            h_diff
+          elsif h_diff > 180
+            h_diff - 360
+          else
+            h_diff + 360
+          end
+      2 * Math.sqrt(lch1[:c] * lch2[:c]) * Math.sin(radians(h) / 2)
+    end
+
+    def mean_hue(lch1, lch2)
+      h_sum = lch1[:h] + lch2[:h]
+      if (lch1[:c] * lch2[:c]).zero?
+        h_sum
+      elsif (lch1[:h] - lch2[:h]).abs <= 180
+        h_sum / 2
+      elsif (lch1[:h] - lch2[:h]).abs > 180 && h_sum < 360
+        (h_sum + 360) / 2
+      else
+        (h_sum - 360) / 2
+      end
+    end
+
+    def radians(num)
+      num * Math::PI / 180
+    end
+
+    def degrees(num)
+      num * 180 / Math::PI
+    end
+  end
+end

data/lib/color_decomposition/image/image_reader.rb

@@ -0,0 +1,35 @@
+require 'rmagick'
+
+module ColorDecomposition
+  class ImageReader
+    include Magick
+    attr_reader :height, :width
+
+    def initialize(path)
+      @image = ImageList.new(path)
+      @height = @image.rows
+      @width = @image.columns
+    end
+
+    def add_image_data(quadtree)
+      quadtree.base_nodes.each do |node|
+        pixels = export_pixel_data(node)
+        node.rgb = {
+          r: ((pixels[0] / 65_535.0) * 255).to_i,
+          g: ((pixels[1] / 65_535.0) * 255).to_i,
+          b: ((pixels[2] / 65_535.0) * 255).to_i
+        }
+      end
+    end
+
+    private
+
+    def export_pixel_data(node)
+      @image.export_pixels(
+        node.rect[:left], node.rect[:top],
+        node.rect[:bottom] - node.rect[:top],
+        node.rect[:right] - node.rect[:left], 'RGB'
+      )
+    end
+  end
+end

data/lib/color_decomposition/quadtree/node.rb

@@ -0,0 +1,68 @@
+require 'color_decomposition/color/color'
+require 'color_decomposition/color/comparator'
+
+module ColorDecomposition
+  class Node
+    include Comparator
+    attr_accessor :rgb
+    attr_reader :rect, :child_nodes
+
+    def initialize(rect, rgb = nil, lab = nil, child_nodes = nil)
+      @rect = rect
+      @rgb = rgb
+      @lab = lab
+      @child_nodes = child_nodes
+    end
+
+    def leaf?
+      @child_nodes.nil?
+    end
+
+    def child_leaves?
+      @child_nodes.all?(&:leaf?)
+    end
+
+    def split
+      center_x = (rect[:left] + rect[:right]) * 0.5
+      center_y = (rect[:top] + rect[:bottom]) * 0.5
+      @child_nodes = [
+        new_child_node(rect[:left], rect[:top], center_x, center_y),
+        new_child_node(center_x, rect[:top], rect[:right], center_y),
+        new_child_node(rect[:left], center_y, center_x, rect[:bottom]),
+        new_child_node(center_x, center_y, rect[:right], rect[:bottom])
+      ]
+    end
+
+    def merge
+      @rgb = @child_nodes[0].rgb
+      @lab = @child_nodes[0].lab
+      @child_nodes = nil
+    end
+
+    def similar?(amount)
+      v1 = ciede2000(@child_nodes[0].lab, @child_nodes[1].lab)
+      v2 = ciede2000(@child_nodes[2].lab, @child_nodes[3].lab)
+      v3 = ciede2000(@child_nodes[0].lab, @child_nodes[2].lab)
+      v1 < amount && v2 < amount && v3 < amount
+    end
+
+    def lab
+      @lab ||= Color.new(@rgb).lab
+    end
+
+    def rgb_hex
+      "##{hex(rgb[:r])}#{hex(rgb[:g])}#{hex(rgb[:b])}"
+    end
+
+    private
+
+    def new_child_node(left, top, right, bottom)
+      Node.new(left: left.floor, top: top.floor,
+               right: right.ceil, bottom: bottom.ceil)
+    end
+
+    def hex(num)
+      format('%02X', num)
+    end
+  end
+end

data/lib/color_decomposition/quadtree/quadtree.rb

@@ -0,0 +1,60 @@
+require 'color_decomposition/quadtree/node'
+
+module ColorDecomposition
+  class Quadtree
+    attr_reader :root
+
+    def initialize(width, height)
+      @root = Node.new(left: 0, top: 0, right: width, bottom: height)
+    end
+
+    def base_nodes
+      generate_to_base(nodes = [], max_level)
+      nodes
+    end
+
+    def generate_similarity_tree(similarity)
+      level = max_level - 1
+      level.times do
+        nodes_from_level(nodes = [], level)
+        nodes.each do |node|
+          node.merge if node.child_leaves? && node.similar?(similarity)
+        end
+        level -= 1
+      end
+    end
+
+    private
+
+    def nodes_from_level(nodes, desired_level, node = @root, level = 0)
+      if level == desired_level
+        nodes.push(node)
+      else
+        unless node.leaf?
+          node.child_nodes.each do |inner_node|
+            nodes_from_level(nodes, desired_level, inner_node, level + 1)
+          end
+        end
+      end
+    end
+
+    def generate_to_base(nodes, desired_level, node = @root, level = 0)
+      if level == desired_level
+        nodes.push(node)
+      else
+        node.split if node.leaf?
+        node.child_nodes.each do |inner_node|
+          generate_to_base(nodes, desired_level, inner_node, level + 1)
+        end
+      end
+    end
+
+    def max_level
+      level = 0
+      num = [@root.rect[:right] - @root.rect[:left],
+             @root.rect[:bottom] - @root.rect[:top]].max
+      level += 1 while num / 2**(level + 1) >= 1
+      level
+    end
+  end
+end

data/lib/color_decomposition/version.rb

@@ -0,0 +1,3 @@
+module ColorDecomposition
+  VERSION = '0.0.1'.freeze
+end

data/lib/color_decomposition.rb

@@ -0,0 +1,21 @@
+require 'color_decomposition/quadtree/quadtree'
+require 'color_decomposition/image/image_reader'
+require 'color_decomposition/version'
+
+module ColorDecomposition
+  module_function
+
+  def quadtree(path, similarity)
+    unless similarity.between?(0, 100)
+      raise ArgumentError, 'Similarity value must be between 0 and 100'
+    end
+    image = ImageReader.new(path)
+    puts 'Generating initial quadtree structure'
+    quadtree = Quadtree.new(image.width, image.height)
+    image.add_image_data(quadtree)
+    puts 'Checking quadtree levels'
+    quadtree.generate_similarity_tree(similarity)
+    puts 'Quadtree complete'
+    quadtree.root
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: color_decomposition
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jonas Bleyl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.16'
+description: Create a quadtree by decomposing images by color using CIELAB.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- color_decomposition.gemspec
+- lib/color_decomposition.rb
+- lib/color_decomposition/color/color.rb
+- lib/color_decomposition/color/comparator.rb
+- lib/color_decomposition/image/image_reader.rb
+- lib/color_decomposition/quadtree/node.rb
+- lib/color_decomposition/quadtree/quadtree.rb
+- lib/color_decomposition/version.rb
+homepage: https://github.com/jonasbleyl/color-decomposition
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Quadtree decomposition of images by color.
+test_files: []