color_calculator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4095a8dfe79681c7faf97a1610b6fd5f88b8202b4db278543db7dd8c639e1a88
+  data.tar.gz: 15cd1be590199c95cbb52d68241cde2a8ba26953aba0832a366e799ed33d359b
+SHA512:
+  metadata.gz: f74c83270cf82df3853bc03428069a0760c575a39a48d7e32e1bd2cd1b5ea73bb955892691dfeec1e56900958c3338e9f2d4bb5d244d211852080ff0373cc10b
+  data.tar.gz: e4602a3606d6a679512b7f621b116e017e99e59ee93b4e3ce316a60814cb3a095ac5fdb86d1a6fb32b4100146e6fd87b0f9e720ac62910835bb2bb282f0623b7

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'pry'
+  gem 'pry-byebug'
+end

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/test_*.rb']
+end
+
+task :default => :test

data/lib/color_calculator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'color_calculator/clump'
+require_relative 'color_calculator/conversion'
+require_relative 'color_calculator/calculation'
+
+module ColorCalculator; end

data/lib/color_calculator/calculation.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'calculation/delta_e_2000'
+
+module ColorCalculator
+  module Calculation; end
+end

data/lib/color_calculator/calculation/delta_e_2000.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'color_calculator/clump/lab'
+
+module ColorCalculator
+  module Calculation
+    class DeltaE2000
+      class << self
+        def call(*args)
+          new(*args).call
+        end
+      end
+
+      RADIANS_TO_DEGREES = 180.to_f / Math::PI
+      DEGREES_TO_RADIANS = 1.to_f / RADIANS_TO_DEGREES
+
+      K_OF_L = 1
+      K_OF_C = 1
+      K_OF_H = 1
+
+      def initialize(sample, reference)
+        @sample = sample
+        @reference = reference
+      end
+
+      def call
+        Math.sqrt(
+          [
+            Rational(delta_l_prime, K_OF_L * s_of_l) ** 2,
+            Rational(delta_c_prime, K_OF_C * s_of_c) ** 2,
+            Rational(delta_h_prime, K_OF_H * s_of_h) ** 2,
+            [
+              r_of_t,
+              Rational(delta_c_prime, K_OF_C * s_of_c),
+              Rational(delta_h_prime, K_OF_H * s_of_h),
+            ].reduce(:*)
+          ].reduce(:+)
+        )
+      end
+
+      private
+
+      attr_reader :sample, :reference
+
+      def delta_l_prime
+        sample.lightness - reference.lightness
+      end
+
+      def s_of_l
+        1 + Rational(
+          0.015 * ((l_bar_prime - 50) ** 2),
+          Math.sqrt(20 + ((l_bar_prime - 50) ** 2))
+        )
+      end
+
+      def delta_c_prime
+        c_prime_sample - c_prime_reference
+      end
+
+      def s_of_c
+        1 + 0.045 * c_bar_prime
+      end
+
+      def delta_h_prime
+        [
+          2,
+          Math.sqrt(c_prime_reference * c_prime_sample),
+          Math.sin(Rational(delta_little_h_prime, 2) * DEGREES_TO_RADIANS),
+        ].reduce(:*)
+      end
+
+      def s_of_h
+        1 + 0.015 * c_bar_prime * big_t
+      end
+
+      def r_of_t
+        -1 * Math.sin(2 * delta_theta * DEGREES_TO_RADIANS) * r_of_c
+      end
+
+      %i[reference sample].each do |lab|
+        define_method("c_#{lab}") do
+          %i[alpha beta].
+            map { |val| send(lab).public_send(val) ** 2 }.
+            reduce(:+) ** Rational(1, 2)
+        end
+      end
+
+      def c_bar
+        (c_reference + c_sample) / 2.0
+      end
+
+      def big_g
+        0.5 * (1 - Math.sqrt(Rational(c_bar ** 7, c_bar ** 7 + 25 ** 7)))
+      end
+
+      %i[reference sample].each do |lab|
+        # def a_prime_reference
+        # def a_prime_sample
+        define_method("a_prime_#{lab}") do
+          (1 + big_g) * send(lab).alpha
+        end
+      end
+
+      %i[reference sample].each do |lab|
+        # def c_prime_reference
+        # def c_prime_sample
+        define_method("c_prime_#{lab}") do
+          Math.sqrt(send("a_prime_#{lab}") ** 2 + send(lab).beta ** 2)
+        end
+      end
+
+      %i[reference sample].each do |lab|
+        # def little_h_prime_reference
+        # def little_h_prime_sample
+        define_method("little_h_prime_#{lab}") do
+          return 0 if [send(lab).beta, send("a_prime_#{lab}")].all? { |el| el == 0 }
+
+          (Math.atan2(send(lab).beta, send("a_prime_#{lab}")) * RADIANS_TO_DEGREES) % 360
+        end
+      end
+
+      def delta_little_h_prime
+        c_prime_product = c_prime_reference * c_prime_sample
+        difference = little_h_prime_sample - little_h_prime_reference
+
+        if c_prime_product.zero?
+          0
+        elsif !c_prime_product.zero? && difference.abs <= 180
+          difference
+        elsif !c_prime_product.zero? && difference > 180
+          difference - 360
+        elsif !c_prime_product.zero? && difference < -180
+          difference + 360
+        else
+          raise "SOMETHING IS WRONG"
+        end
+        # return 0 if c_prime_sample * c_prime_reference == 0
+
+        # val = little_h_prime_sample - little_h_prime_reference
+
+        # return val if val.abs >= 180
+        # sign = val <=> 0
+
+        # val - sign * 360
+      end
+
+      def l_bar_prime
+        Rational(reference.lightness + sample.lightness, 2)
+      end
+      
+      def c_bar_prime
+        Rational(c_prime_reference + c_prime_sample, 2)
+      end
+
+      def little_h_bar_prime
+        sum = little_h_prime_reference + little_h_prime_sample
+        difference = little_h_prime_reference - little_h_prime_sample
+        c_prime_product = c_prime_reference * c_prime_sample
+
+
+        if difference.abs <= 180 && !c_prime_product.zero?
+          Rational(sum, 2)
+        elsif difference.abs > 180 && sum < 360 && !c_prime_product.zero?
+          Rational(sum + 360, 2)
+        elsif difference.abs > 180 && sum >= 360 && !c_prime_product.zero?
+          Rational(sum - 360, 2)
+        elsif c_prime_product.zero?
+          sum
+        else
+          raise "SOMETHING IS WRONG"
+        end
+      end
+
+      def big_t
+        [
+          1,
+          -0.17 * Math.cos((little_h_bar_prime - 30) * DEGREES_TO_RADIANS),
+          0.24 * Math.cos(2 * little_h_bar_prime * DEGREES_TO_RADIANS),
+          0.32 * Math.cos((3 * little_h_bar_prime + 6) * DEGREES_TO_RADIANS),
+          -0.2 * Math.cos((4 * little_h_bar_prime - 63) * DEGREES_TO_RADIANS),
+        ].reduce(:+)
+      end
+
+      def delta_theta
+        30 * Math::E ** (-1 * (Rational(little_h_bar_prime - 275, 25) ** 2))
+      end
+
+      def r_of_c
+        2 * Math.sqrt(Rational(c_bar_prime ** 7, c_bar_prime ** 7 + 25 ** 7))
+      end
+    end
+  end
+end

data/lib/color_calculator/clump.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'clump/abstract'
+require_relative 'clump/lab'
+require_relative 'clump/lch_ab'
+require_relative 'clump/rgb'
+require_relative 'clump/xyz'
+
+module ColorCalculator
+  module Clump; end
+end

data/lib/color_calculator/clump/abstract.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ColorCalculator
+  module Clump
+    class UnlikeComparisonError < StandardError; end
+
+    class Abstract
+      def initialize(*attributes)
+        self.class.attributes.each.with_index do |name, index|
+          instance_variable_set("@#{name}".to_sym, attributes[index])
+
+          define_singleton_method(name) do
+            instance_variable_get("@#{name}".to_sym)
+          end
+        end
+      end
+
+      def to_h
+        self.class.attributes.reduce({}) do |memo, message|
+          memo.merge(message => public_send(message))
+        end
+      end
+
+      def ==(other)
+        raise UnlikeComparisonError if self.class != other.class
+
+        to_h == other.to_h
+      end
+
+      def inspect
+        to_h.to_s
+      end
+      alias_method :to_s, :inspect
+    end
+  end
+end

data/lib/color_calculator/clump/lab.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+
+module ColorCalculator
+  module Clump
+    class Lab < Abstract
+      class << self
+        def attributes
+          %i[lightness alpha beta]
+        end
+      end
+    end
+  end
+end

data/lib/color_calculator/clump/lch_ab.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+
+module ColorCalculator
+  module Clump
+    class LchAb < Abstract
+      class << self
+        def attributes
+          %i[lightness chroma hue]
+        end
+      end
+    end
+  end
+end

data/lib/color_calculator/clump/rgb.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+
+module ColorCalculator
+  module Clump
+    class Rgb < Abstract
+      class << self
+        def attributes
+          %i[red green blue]
+        end
+      end
+
+      def initialize(*attributes, normalized:)
+        @red, @green, @blue = attributes
+        @normalized = normalized
+      end
+
+      %i[red green blue].each do |value|
+        define_method(value) do
+          Rational(instance_variable_get("@#{value}"), scale)
+        end
+      end
+
+      private
+
+      attr_reader :normalized
+
+      def scale
+        normalized ? 1 : 255
+      end
+    end
+  end
+end

data/lib/color_calculator/clump/xyz.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+
+module ColorCalculator
+  module Clump
+    class Xyz < Abstract
+      class << self
+        def attributes
+          %i[x y z]
+        end
+      end
+    end
+  end
+end

data/lib/color_calculator/conversion.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'conversion/lab_to_lch_ab'
+require_relative 'conversion/rgb_to_xyz'
+require_relative 'conversion/rgb_to_lch_ab'
+require_relative 'conversion/xyz_to_lab'
+
+module ColorCalculator
+  module Conversion; end
+end

data/lib/color_calculator/conversion/lab_to_lch_ab.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'color_calculator/clump/lab'
+require 'color_calculator/clump/lch_ab'
+require 'color_calculator/shared/composable'
+
+module ColorCalculator
+  module Conversion
+    class LabToLchAb
+      extend ColorCalculator::Composable
+
+      RADIANS_TO_DEGREES = 180 / Math::PI
+
+      def initialize(lab)
+        @lab = lab
+      end
+
+      def call
+        ColorCalculator::Clump::LchAb.new(lightness, chroma, hue)
+      end
+
+      private
+
+      attr_reader :lab
+
+      def lightness
+        lab.lightness
+      end
+
+      def chroma
+        (lab.alpha ** 2 + lab.beta ** 2) ** Rational(1, 2)
+      end
+
+      def hue
+        val = Math.atan2(lab.beta, lab.alpha) * RADIANS_TO_DEGREES
+
+        return val if val >= 0
+
+        val + 360
+      end
+    end
+  end
+end

data/lib/color_calculator/conversion/rgb_to_lch_ab.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'color_calculator/shared/composable'
+
+module ColorCalculator
+  module Conversion
+    class RgbToLchAb
+      extend ColorCalculator::Composable
+
+      def initialize(rgb)
+        @rgb = rgb
+      end
+
+      def call
+        composed_path.call(rgb)
+      end
+
+      private
+
+      attr_reader :rgb
+
+      def composed_path
+        conversion_path.map(&:to_proc).reduce(:>>)
+      end
+
+      def conversion_path
+        [
+          ColorCalculator::Conversion::RgbToXyz,
+          ColorCalculator::Conversion::XyzToLab,
+          ColorCalculator::Conversion::LabToLchAb
+        ]
+      end
+    end
+  end
+end

data/lib/color_calculator/conversion/rgb_to_xyz.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'color_calculator/clump/rgb'
+require 'color_calculator/clump/xyz'
+require 'color_calculator/shared/composable'
+
+module ColorCalculator
+  module Conversion
+    class RgbToXyz
+      extend ColorCalculator::Composable
+
+      def initialize(rgb)
+        @rgb = rgb
+      end
+
+      def call
+        ColorCalculator::Clump::Xyz.new(x, y, z)
+      end
+
+      APPLE = -> (value) do
+        value / 12.92
+      end
+
+      BANANA = -> (value) do
+        ((value + 0.055)/1.055) ** Rational(12, 5)
+      end
+
+      FRUIT = -> (value) do
+        (value <= 0.04045 ? APPLE : BANANA).call(value)
+      end
+
+      RGB_TO_XYZ_TRANSFORM_D50 = [
+       [0.4360747, 0.3850649, 0.1430804],
+       [0.2225045, 0.7168786, 0.0606169],
+       [0.0139322, 0.0971045, 0.7141733],
+      ]
+
+      private
+
+      attr_reader :rgb
+
+      def transformed_rgb
+        Hash[
+          [:red, :green, :blue].zip(
+            RGB_TO_XYZ_TRANSFORM_D50.map do |row|
+              %i[red green blue].map.with_index do |rgb, index|
+                row[index] * energetically_linear_rgb[rgb]
+              end.inject(:+)
+            end
+          )
+        ]
+      end
+
+      def energetically_linear_rgb
+        Hash[
+          %i[red green blue].map do |color|
+            [color, FRUIT.call(rgb.public_send(color))]
+          end
+        ]
+      end
+
+      (%i[x y z].zip(%i[red green blue])).each do |xyz, rgb|
+        define_method(xyz) do
+          transformed_rgb[rgb]
+        end
+      end
+    end
+  end
+end

data/lib/color_calculator/conversion/xyz_to_lab.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'color_calculator/clump/lab'
+require 'color_calculator/clump/xyz'
+require 'color_calculator/shared/composable'
+
+module ColorCalculator
+  module Conversion
+    class XyzToLab
+      extend ColorCalculator::Composable
+
+      D50 = { x: 0.964220, y: 1.000000, z: 0.825210 }
+      EPSILON = 0.008856
+      KAPPA = 903.3
+
+      APPLE = -> (value) do
+        value ** Rational(1, 3)
+      end
+
+      BANANA = -> (value) do
+        ((KAPPA * value) + 16) / 116
+      end
+
+      FRUIT = -> (value) do
+        (value > EPSILON ? APPLE : BANANA).call(value)
+      end
+
+      def initialize(xyz)
+        @xyz = xyz
+      end
+
+      def call
+        ColorCalculator::Clump::Lab.new(lightness, alpha, beta)
+      end
+
+      private
+
+      attr_reader :xyz
+
+      def lightness
+        (116 * FRUIT.call(y_scaled)) - 16
+      end
+
+      def alpha
+        500 * (FRUIT.call(x_scaled) - FRUIT.call(y_scaled))
+      end
+
+      def beta
+        200 * (FRUIT.call(y_scaled) - FRUIT.call(z_scaled))
+      end
+
+      %i[x y z].each do |symbol|
+        define_method("#{symbol}_scaled") do
+          xyz.public_send(symbol) / D50.fetch(symbol)
+        end
+      end
+    end
+  end
+end

data/lib/color_calculator/shared/composable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ColorCalculator
+  module Composable
+    def to_proc
+      proc(&method(:call))
+    end
+
+    def call(args)
+      new(args).call
+    end
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: color_calculator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nathan Seither
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-03-03 00:00:00.000000000 Z
+dependencies: []
+description: You can do color math now!
+email:
+- nathanseither@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Rakefile
+- lib/color_calculator.rb
+- lib/color_calculator/calculation.rb
+- lib/color_calculator/calculation/delta_e_2000.rb
+- lib/color_calculator/clump.rb
+- lib/color_calculator/clump/abstract.rb
+- lib/color_calculator/clump/lab.rb
+- lib/color_calculator/clump/lch_ab.rb
+- lib/color_calculator/clump/rgb.rb
+- lib/color_calculator/clump/xyz.rb
+- lib/color_calculator/conversion.rb
+- lib/color_calculator/conversion/lab_to_lch_ab.rb
+- lib/color_calculator/conversion/rgb_to_lch_ab.rb
+- lib/color_calculator/conversion/rgb_to_xyz.rb
+- lib/color_calculator/conversion/xyz_to_lab.rb
+- lib/color_calculator/shared/composable.rb
+homepage: https://github.com/Supernats/color_calculator
+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.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Color math calculators and converters
+test_files: []