color_diff 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d4856b49dfb2ca4f6fc555def253b3aa586cdc01
+  data.tar.gz: 1f38316a2e62d067e0edf4772f03d787bc057be2
+SHA512:
+  metadata.gz: 6d9d78fb545168a91a75f303a8e5f3fa36bd32bac2057b27621ccd992954ebf97d3ddc8a800d4575e439bab248910859f0f662113f38155716254b09d881356d
+  data.tar.gz: faceec60200cf5b91ad725db8d9400d329c6ba6a55aeb426f0f4a3b6f3f022af6381bc0eb5426da03e0df9460be88ed6da5146b3fab49dae2447777924f63ec4

data/LICENSE

@@ -0,0 +1,18 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Daniel Hanson
+
+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 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,41 @@
+# Color Diff
+
+Calculating differences between colors using the CIEDE2000 algorithm
+
+## Install
+
+    gem install color_diff
+
+## Usage
+
+Difference between two colors:
+
+    yellow = ColorDiff::Color::RGB.new 255, 255, 0
+    gold   = ColorDiff::Color::RGB.new 255, 215, 0
+
+    ColorDiff.between yellow, gold
+    # => 11.584521223499245
+
+Picking the most similar color from a list:
+
+    red    = ColorDiff::Color::RGB.new 255,   0,   0
+    blue   = ColorDiff::Color::RGB.new   0,   0, 255
+    yellow = ColorDiff::Color::RGB.new 255, 255,   0
+    gold   = ColorDiff::Color::RGB.new 255, 215,   0
+
+    list   = ColorDiff::List.new [red, blue, yellow]
+    list.closest_to(gold) == yellow
+    # => true
+
+Building a map of nearest match colors from a finite palette:
+
+    red       = ColorDiff::Color::RGB.new 255,  0,  0
+    black     = ColorDiff::Color::RGB.new   0,  0,  0
+    dark_gray = ColorDiff::Color::RGB.new  80, 80, 80
+    maroon    = ColorDiff::Color::RGB.new 128,  0,  0
+
+    list = ColorDiff::List.new [red, black]
+    palette = [dark_gray, maroon]
+
+    list.closest_to_map(palette)
+    # => { 'R255G0B0' => maroon, 'R0B0G0' => dark_gray }

data/lib/color_diff.rb

@@ -0,0 +1,35 @@
+require 'color_diff/color/rgb'
+require 'color_diff/color/xyz'
+require 'color_diff/color/lab'
+require 'color_diff/ciede2000'
+require 'color_diff/list'
+
+module ColorDiff
+  # = Color Diff
+  #
+  # Color Diff contains a number of methods to assist in measuring how similar
+  # or dissimilar colors are from one another
+  #
+  # == Simple Comparison
+  #
+  # Two color objects can be compared like so:
+  #
+  #   yellow = ColorDiff::Color::RGB.new(255, 255, 0)
+  #   gold   = ColorDiff::Color::RGB.new(255, 215, 0)
+  #   ColorDiff.between(yellow, gold) => 11.584521223499245
+  #
+  # The higher the result the more dissimilar the colors, e.g.
+  #
+  #   blue = ColorDiff::Color::RGB.new(0, 0, 255)
+  #   red  = ColorDiff::Color::RGB.new(255, 0, 0)
+  #   ColorDiff.between(blue, red) => 52.87867414046132
+  #
+  # See ColorDiff::List for example of more complex comparisons
+
+  def self.between(lab1, lab2)
+    lab1 = lab1.to_lab unless lab1.is_a? Color::Lab
+    lab2 = lab2.to_lab unless lab2.is_a? Color::Lab
+
+    ColorDiff::Ciede2000.diff(lab1, lab2)
+  end
+end

data/lib/color_diff/ciede2000.rb

@@ -0,0 +1,115 @@
+module ColorDiff
+  class Ciede2000
+    def self.diff(c1, c2)
+      # get lab values for color 1
+      l1 = c1.l
+      a1 = c1.a
+      b1 = c1.b
+
+      # get lab values for color 2
+      l2 = c2.l
+      a2 = c2.a
+      b2 = c2.b
+
+      # weight factors
+      kl = 1
+      kc = 1
+      kh = 1
+
+      # Step 1: Calculate c1p, c2p, h1p, h2p
+      #
+      c1 = Math.sqrt((a1 ** 2) + (b1 ** 2))
+      c2 = Math.sqrt((a2 ** 2) + (b2 ** 2))
+
+      a_c1_c2 = (c1 + c2) / 2.0
+
+      g = 0.5 * (1 - Math.sqrt((a_c1_c2 ** 7.0) / ((a_c1_c2 ** 7.0) + (25.0 ** 7.0))))
+
+      a1p = (1.0 + g) * a1
+      a2p = (1.0 + g) * a2
+      c1p = Math.sqrt((a1p ** 2) + (b1 ** 2))
+      c2p = Math.sqrt((a2p ** 2) + (b2 ** 2))
+      h1p = hp_f(b1, a1p)
+      h2p = hp_f(b2, a2p)
+
+      # Step 2: calculate dlp, dcp, dhp
+      #
+      dlp = l2 - l1
+      dcp = c2p - c1p
+      dhp_tmp = dhp_f(c1, c2, h1p, h2p)
+      dhp = 2 * Math.sqrt(c1p * c2p) * Math.sin(radians(dhp_tmp) / 2.0)
+
+      # Step 3: calculate CIEDE2000 Color-Difference
+      #
+      a_l = (l1 + l2) / 2.0
+      a_cp = (c1p + c2p) / 2.0
+      a_hp = a_hp_f(c1, c2, h1p, h2p)
+      t = 1 -
+          0.17 * Math.cos(radians(a_hp - 30)) +
+          0.24 * Math.cos(radians(2 * a_hp)) +
+          0.32 * Math.cos(radians(3 * a_hp + 6)) -
+          0.20 * Math.cos(radians(4 * a_hp - 63))
+      d_ro = 30 * Math.exp(-(((a_hp - 275) / 25) ** 2))
+      rc = Math.sqrt((a_cp ** 7.0) / ((a_cp ** 7.0) + (25.0 ** 7.0)))
+      sl = 1 + ((0.015 * ((a_l - 50) ** 2)) / Math.sqrt(20 + ((a_l - 50) ** 2.0)))
+      sc = 1 + 0.045 * a_cp
+      sh = 1 + 0.015 * a_cp * t
+      rt = -2 * rc * Math.sin(radians(2 * d_ro))
+      de = Math.sqrt(
+             ((dlp / (sl * kl)) ** 2) +
+             ((dcp / (sc * kc)) ** 2) +
+             ((dhp / (sh * kh)) ** 2) + 
+             rt * (dcp / (sc * kc)) * (dhp / (sh * kh)) )
+
+      de
+    end
+
+    def self.degrees(n)
+      180 / Math::PI * n
+    end
+
+    def self.radians(n)
+      Math::PI / 180 * n
+    end
+
+    def self.hp_f(x, y)
+      0 if x.zero? && y.zero?
+
+      tmphp = degrees Math.atan2(x, y)
+      if tmphp >= 0
+        tmphp
+      else
+        tmphp + 360
+      end
+    end
+
+    def self.dhp_f(c1, c2, h1p, h2p)
+      diff = h2p - h1p
+
+      if c1 * c2 == 0
+        0
+      elsif diff.abs <= 180
+        diff
+      elsif diff > 180
+        diff - 360
+      elsif diff < -180
+        diff + 360
+      end
+    end
+
+    def self.a_hp_f(c1, c2, h1p, h2p)
+      sum = h1p + h2p
+      diff = h1p - h2p
+
+      if c1 * c2 == 0
+        sum
+      elsif diff.abs <= 180
+        sum / 2.0
+      elsif diff.abs > 180 && sum < 360
+        (sum + 360) / 2.0
+      elsif diff.abs > 180 && sum >= 360
+        (sum - 360) / 2.0
+      end
+    end
+  end
+end

data/lib/color_diff/color/lab.rb

@@ -0,0 +1,46 @@
+module ColorDiff
+  module Color
+    class Lab
+      attr_reader :l, :a, :b
+
+      PRECISION = 3
+
+      def initialize(l = 0, a = 0, b = 0)
+        @l = l
+        @a = a
+        @b = b
+      end
+
+      def self.from_xyz(xyz)
+        ref_x = 95.047
+        ref_y = 100.000
+        ref_z = 108.883
+        x = xyz.x / ref_x
+        y = xyz.y / ref_y
+        z = xyz.z / ref_z
+
+        x = normalize_xyz_component(x)
+        y = normalize_xyz_component(y)
+        z = normalize_xyz_component(z)
+
+        l = (116 * y) - 16
+        a = 500 * (x - y)
+        b = 200 * (y - z)
+
+        new(l, a, b)
+      end
+
+      def self.normalize_xyz_component(c)
+        if c > 0.008856
+          c ** (1 / 3.0)
+        else
+          (c * 7.787) + (16 / 116.0)
+        end
+      end
+
+      def to_s
+        "L#{@l.round(PRECISION)}A#{@a.round(PRECISION)}B#{@b.round(PRECISION)}"
+      end
+    end
+  end
+end

data/lib/color_diff/color/rgb.rb

@@ -0,0 +1,25 @@
+module ColorDiff
+  module Color
+    class RGB
+      attr_reader :r, :g, :b
+
+      def initialize(r = 0, g = 0, b = 0)
+        @r = r
+        @g = g
+        @b = b
+      end
+
+      def to_xyz
+        Xyz.from_rgb(self)
+      end
+
+      def to_lab
+        to_xyz.to_lab
+      end
+
+      def to_s
+        "R#{@r}G#{@g}B#{@b}"
+      end
+    end
+  end
+end

data/lib/color_diff/color/xyz.rb

@@ -0,0 +1,41 @@
+module ColorDiff
+  module Color
+    class Xyz
+      attr_reader :x, :y, :z
+
+      def initialize(x = 0, y = 0, z = 0)
+        @x = x
+        @y = y
+        @z = z
+      end
+
+      def to_lab
+        Lab.from_xyz(self)
+      end
+
+      def self.from_rgb(rgb)
+        r = normalize_rgb_component rgb.r
+        g = normalize_rgb_component rgb.g
+        b = normalize_rgb_component rgb.b
+
+        x = r * 0.4124 + g * 0.3576 + b * 0.1805
+        y = r * 0.2126 + g * 0.7152 + b * 0.0722
+        z = r * 0.0193 + g * 0.1192 + b * 0.9505
+
+        new(x, y, z)
+      end
+
+      def self.normalize_rgb_component(c)
+        c = c / 255.0
+
+        if c > 0.04045
+          c = ((c + 0.055) / 1.055) ** 2.4
+        else
+          c = c / 12.92
+        end
+
+        c * 100
+      end
+    end
+  end
+end

data/lib/color_diff/list.rb

@@ -0,0 +1,67 @@
+module ColorDiff
+  class List
+    # +items+ An array of ColorDiff::Colors
+    def initialize(items)
+      @items = items
+    end
+
+    # Compares all +items+ in the list to the supplied +color+ and returns
+    # the most similar
+    #
+    # +color+ ColorDiff::Color to compare against the list
+    #
+    # == Example
+    #
+    #   red    = ColorDiff::Color::RGB.new(255, 0, 0)
+    #   blue   = ColorDiff::Color::RGB.new(0, 0, 255)
+    #   yellow = ColorDiff::Color::RGB.new(255, 255, 0)
+    #   gold   = ColorDiff::Color::RGB.new(255, 215, 0)
+    #
+    #   list   = ColorDiff::List.new [red, blue, yellow]
+    #   list.closest_to(gold) == yellow => true
+    #
+    def closest_to(color)
+      closest_color = nil
+      closest_diff = 100
+
+      @items.each do |item|
+        diff = ColorDiff.between(color, item)
+        if diff < closest_diff
+          closest_diff = diff
+          closest_color = item
+        end
+      end
+
+      closest_color
+    end
+
+    # Compares all +items+ in the list against the supplied +palette+ and
+    # maps each item to the closest palette color.  The resulting hash is 
+    # returned
+    #
+    # +palette+ Array of ColorDiff::Colors to compare against the list
+    #
+    # == Example
+    #
+    #   red       = ColorDiff::Color::RGB.new(255, 0, 0)
+    #   black     = ColorDiff::Color::RGB.new(0, 0, 0)
+    #   dark_gray = ColorDiff::Color::RGB.new(80, 80, 80)
+    #   maroon    = ColorDiff::Color::RGB.new(128, 0, 0)
+    #
+    #   list = ColorDiff::List.new [red, black]
+    #   palette = [dark_gray, maroon]
+    #
+    #   list.closest_to_map(palette) =>
+    #     { 'R255G0B0' => maroon, 'R0B0G0' => dark_gray }
+    #
+    def closest_to_map(palette)
+      map = {}
+      options = List.new(palette)
+      @items.each do |item|
+        map[item.to_s] = options.closest_to item
+      end
+
+      map
+    end
+  end
+end

data/lib/color_diff/version.rb

@@ -0,0 +1,3 @@
+module ColorDiff
+  VERSION = '0.1'
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: color_diff
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Daniel Hanson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Calculate RGB color distances using CIEDE2000 formula
+email: hansondr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/color_diff.rb
+- lib/color_diff/ciede2000.rb
+- lib/color_diff/color/lab.rb
+- lib/color_diff/color/rgb.rb
+- lib/color_diff/color/xyz.rb
+- lib/color_diff/list.rb
+- lib/color_diff/version.rb
+homepage: https://github.com/hansondr/color_diff
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Calculate rgb color distances using CIEDE2000 formula
+test_files: []