recolor 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0f36003993048fe3779cebfe5a674e7937e9d007
+  data.tar.gz: e9b3747ba265f90aa021973729071aa218c4e475
+SHA512:
+  metadata.gz: de88f6cc4fa94eab41a2f2bf3cc1a0f746993a5a314a729cf4315efbef415fa309ee1ee150cd2cf168b2d3b38b73d7af4de4e5b599277588974baf1f7c8bba4e
+  data.tar.gz: 3a708f24e8a041cfd1d83aaa013106fe532bd1d234927e1d72fa48a0ba055294a70d33be56967c517966710d557bbc0a317ca35957d20d00c61ba03afb15cc86

data/lib/recolor.rb

@@ -0,0 +1,70 @@
+require "recolor/version"
+
+module Recolor
+  require "recolor/color"
+  require "recolor/models"
+  require "recolor/models/hex"
+  require "recolor/models/hsluv"
+  require "recolor/models/hpluv"
+  require "recolor/models/lch"
+  require "recolor/models/luv"
+  require "recolor/models/rgb"
+  require "recolor/models/xyz"
+  require "recolor/converter"
+
+  class Recolor
+    attr_accessor :converter
+    attr_accessor :models
+
+    def initialize
+      @models = {}
+      @models[:hex] = Models::Hex.new
+      @models[:hpluv] = Models::HPLuv.new
+      @models[:hsluv] = Models::HSLuv.new
+      @models[:lch] = Models::LCh.new
+      @models[:luv] = Models::Luv.new
+      @models[:rgb] = Models::RGB.new
+      @models[:xyz] = Models::XYZ.new
+      @converter = Converter.new
+      @converter.models[:hex] = @models[:hex]
+      @converter.models[:hpluv] = @models[:hpluv]
+      @converter.models[:hsluv] = @models[:hsluv]
+      @converter.models[:lch] = @models[:lch]
+      @converter.models[:luv] = @models[:luv]
+      @converter.models[:rgb] = @models[:rgb]
+      @converter.models[:xyz] = @models[:xyz]
+    end
+
+    def color(model, tuple)
+      @color = Color.new(model, tuple)
+
+      return self.clone
+    end
+
+    def to(model)
+      raise Exception.new("Color definition not found.") unless @color
+
+      source = @color.model
+      tuple = @color.tuple
+      tuple = @converter.convert(tuple, source, model)
+
+      return color(model, tuple)
+    end
+
+    def model
+      return @color.model
+    end
+
+    def tuple
+      return @color.tuple
+    end
+
+    def format
+      yield @color.tuple
+    end
+
+    def to_s
+      return @models[model].print(tuple)
+    end
+  end
+end

data/lib/recolor/color.rb

@@ -0,0 +1,11 @@
+module Recolor
+  class Color
+    attr_accessor :model
+    attr_accessor :tuple
+
+    def initialize(model, tuple)
+      @model = model
+      @tuple = tuple
+    end
+  end
+end

data/lib/recolor/converter.rb

@@ -0,0 +1,53 @@
+module Recolor
+  class Converter
+    attr_accessor :models
+
+    def initialize
+      @models = {}
+    end
+
+    def convert(tuple, source, destination)
+      return tuple unless source != destination
+
+      raise ArgumentError.new("No #{source} model found.") unless @models.include?(source)
+
+      @steps = []
+      resolve(source, destination, @models)
+
+      raise ArgumentError.new("Unable to convert from #{source} to #{destination}.") if @steps.empty?
+
+      model = @models[source]
+
+      @steps.each do |step|
+        tuple = model.send(step, tuple)
+        model = @models[step]
+      end
+
+      return tuple
+    end
+
+    private
+
+    def resolve(source, destination, models)
+      model = models[source]
+      models = models.reject { |name| name == source }
+
+      models.keys.each do |name|
+        if model.respond_to?(destination)
+          @steps << destination
+        end
+
+        if @steps.include?(destination)
+          break
+        end
+
+        if model.respond_to?(name)
+          @steps << name
+          resolve(name, destination, models)
+        end
+      end
+
+      @steps = @steps.reject { |name| name == source } unless @steps.include?(destination)
+    end
+  end
+end

data/lib/recolor/models.rb

@@ -0,0 +1,20 @@
+module Recolor
+  module Models
+    class Model
+      attr_accessor :format
+
+      KAPPA = 903.2962962962963
+      EPSILON = 0.0088564516790356308
+
+      def initialize
+        @format = lambda do |tuple|
+          return tuple
+        end
+      end
+
+      def print(tuple)
+        return "#{@format.call(tuple)}"
+      end
+    end
+  end
+end

data/lib/recolor/models/hex.rb

@@ -0,0 +1,21 @@
+module Recolor
+  module Models
+    class Hex < Model
+      def rgb(tuple)
+        hex = [
+          tuple[0],
+          tuple[1],
+          tuple[2]
+        ]
+
+        rgb = hex.map do |v|
+          v = v + v if v.length == 1
+          v = v.hex
+          v = v / 255
+        end
+
+        return rgb
+      end
+    end
+  end
+end

data/lib/recolor/models/hpluv.rb

@@ -0,0 +1,33 @@
+module Recolor
+  module Models
+    class HPLuv < Model
+      def lch(tuple)
+        h = tuple[0]
+        s = tuple[1]
+        l = tuple[2]
+
+        return [100, 0.0, h] if l > 99.9999999
+        return [0.0, 0.0, h] if l < 0.00000001
+
+        chroma = HPLuv.chroma(l)
+        c = chroma / 100.0 * s
+
+        return [l, c, h]
+      end
+
+      def HPLuv.chroma(l)
+        lengths = []
+
+        HSLuv.bounds(l).each do |line|
+          m = line[0]
+          b = line[1]
+          x = (b - 0.0) / ((-1.0 / m) - m)
+          length = Math.sqrt(x**2 + (b + x * m)**2)
+          lengths << length
+        end
+
+        return lengths.min
+      end
+    end
+  end
+end

data/lib/recolor/models/hsluv.rb

@@ -0,0 +1,51 @@
+module Recolor
+  module Models
+    class HSLuv < Model
+      def lch(tuple)
+        h = tuple[0]
+        s = tuple[1]
+        l = tuple[2]
+
+        return [100, 0.0, h] if l > 99.9999999
+        return [0.0, 0.0, h] if l < 0.00000001
+
+        chroma = HSLuv.chroma(l, h)
+        c = chroma / 100.0 * s
+
+        return [l, c, h]
+      end
+
+      def HSLuv.bounds(l)
+        s = ((l + 16)**3) / 1560896.0
+        s = s > EPSILON ? s : l / KAPPA
+        matrix = RGB::MATRIX.to_a
+        lines = []
+
+        matrix.each do |m1, m2, m3|
+          [0, 1].each do |d|
+            bottom = (632260 * m3 - 126452 * m2) * s + 126452 * d
+            m = ((284517 * m1 - 94839 * m3) * s) / bottom
+            b = ((838422 * m3 + 769860 * m2 + 731718 * m1) * l * s - 769860 * d * l) / bottom
+            lines << [m, b]
+          end
+        end
+
+        return lines
+      end
+
+      def HSLuv.chroma(l, h)
+        angle = h / 360.0 * Math::PI * 2.0
+        lengths = []
+
+        HSLuv.bounds(l).each do |line|
+          m = line[0]
+          b = line[1]
+          length = b / (Math.sin(angle) - m * Math.cos(angle))
+          lengths << length if length > 0
+        end
+
+        return lengths.min
+      end
+    end
+  end
+end

data/lib/recolor/models/lch.rb

@@ -0,0 +1,44 @@
+module Recolor
+  module Models
+    class LCh < Model
+      def luv(tuple)
+        l = tuple[0]
+        c = tuple[1]
+        h = tuple[2]
+        h = h * Math::PI / 180.0
+        u = Math::cos(h) * c
+        v = Math::sin(h) * c
+
+        return [l, u, v]
+      end
+
+      def hpluv(tuple)
+        l = tuple[0]
+        c = tuple[1]
+        h = tuple[2]
+
+        return [h, 0.0, 100] if l > 99.9999999
+        return [h, 0.0, 0.0] if l < 0.00000001
+
+        chroma = HPLuv.chroma(l)
+        p = c / chroma * 100.0
+
+        return [h, p, l]
+      end
+
+      def hsluv(tuple)
+        l = tuple[0]
+        c = tuple[1]
+        h = tuple[2]
+
+        return [h, 0.0, 100] if l > 99.9999999
+        return [h, 0.0, 0.0] if l < 0.00000001
+
+        chroma = HSLuv.chroma(l, h)
+        s = c / chroma * 100.8
+
+        return [h, s, l]
+      end
+    end
+  end
+end

data/lib/recolor/models/luv.rb

@@ -0,0 +1,35 @@
+module Recolor
+  module Models
+    class Luv < Model
+      REFERENCE_U = 0.19783000664283
+      REFERENCE_V = 0.46831999493879
+
+      def xyz(tuple)
+        l = tuple[0]
+        u = tuple[1]
+        v = tuple[2]
+
+        return [0.0, 0.0, 0.0] if l == 0.0
+
+        y = l > 8 ? XYZ::REFERENCE_Y * ((l + 16.0) / 116.0)**3.0 : XYZ::REFERENCE_Y * l / KAPPA
+        u = u / (13.0 * l) + REFERENCE_U
+        v = v / (13.0 * l) + REFERENCE_V
+        x = 0.0 - (9.0 * y * u) / ((u - 4.0) * v - u * v)
+        z = (9.0 * y - (15.0 * v * y) - (v * x)) / (3.0 * v)
+
+        return [x, y, z]
+      end
+
+      def lch(tuple)
+        l = tuple[0]
+        u = tuple[1]
+        v = tuple[2]
+        c = Math.sqrt(u * u + v * v)
+        h = Math.atan2(v, u) * 180 / Math::PI
+        h = h < 0.0 ? h + 360.0 : h
+
+        return [l, c, h]
+      end
+    end
+  end
+end

data/lib/recolor/models/rgb.rb

@@ -0,0 +1,38 @@
+require "matrix"
+
+module Recolor
+  module Models
+    class RGB < Model
+      MATRIX = Matrix[
+        [3.240969941904521, -1.537383177570093, -0.498610760293],
+        [-0.96924363628087, 1.87596750150772, 0.041555057407175],
+        [0.055630079696993, -0.20397695888897, 1.056971514242878]
+      ]
+
+      def hex(tuple)
+        hex = tuple.map do |v|
+          v = v * 255
+          v = v.round
+          v = v.to_s(16)
+          v = v.length == 1 ? "0" + v : v
+        end
+
+        return hex
+      end
+
+      def xyz(tuple)
+        rgb = tuple.map do |v|
+          v < 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055)**2.4
+        end
+
+        rgb = Matrix[rgb].transpose
+        xyz = XYZ::MATRIX * rgb
+        xyz = xyz.transpose
+        xyz = xyz.row(0)
+        xyz = xyz.to_a
+
+        return xyz
+      end
+    end
+  end
+end

data/lib/recolor/models/xyz.rb

@@ -0,0 +1,45 @@
+module Recolor
+  module Models
+    class XYZ < Model
+      MATRIX = Matrix[
+        [0.41239079926595, 0.35758433938387, 0.18048078840183],
+        [0.21263900587151, 0.71516867876775, 0.072192315360733],
+        [0.019330818715591, 0.11919477979462, 0.95053215224966]
+      ]
+      REFERENCE_X = 0.95045592705167
+      REFERENCE_Y = 1.0
+      REFERENCE_Z = 1.089057750759878
+
+      def rgb(tuple)
+        xyz = Matrix[tuple].transpose
+        rgb = RGB::MATRIX * xyz
+
+        rgb = rgb.map do |v|
+          v <= 0.0031308 ? 12.92 * v : (1.055 * (v**(1.0 / 2.4)) - 0.055)
+        end
+
+        rgb = rgb.transpose
+        rgb = rgb.row(0)
+        rgb = rgb.to_a
+
+        return rgb
+      end
+
+      def luv(tuple)
+        x = tuple[0]
+        y = tuple[1]
+        z = tuple[2]
+        l = y > EPSILON ? l = 116.0 * ((y / REFERENCE_Y)**(1.0 / 3.0)) - 16.0 : l = y / REFERENCE_Y * KAPPA
+
+        return [0.0, 0.0, 0.0] if l == 0.0
+
+        u = (4.0 * x) / (x + (15.0 * y) + (3.0 * z))
+        v = (9.0 * y) / (x + (15.0 * y) + (3.0 * z))
+        u = 13.0 * l * (u - Luv::REFERENCE_U)
+        v = 13.0 * l * (v - Luv::REFERENCE_V)
+
+        return [l, u, v]
+      end
+    end
+  end
+end

data/lib/recolor/version.rb

@@ -0,0 +1,3 @@
+module Recolor
+  VERSION = "0.1.1"
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: recolor
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Alberto Beloni
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-11 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/recolor.rb
+- lib/recolor/color.rb
+- lib/recolor/converter.rb
+- lib/recolor/models.rb
+- lib/recolor/models/hex.rb
+- lib/recolor/models/hpluv.rb
+- lib/recolor/models/hsluv.rb
+- lib/recolor/models/lch.rb
+- lib/recolor/models/luv.rb
+- lib/recolor/models/rgb.rb
+- lib/recolor/models/xyz.rb
+- lib/recolor/version.rb
+homepage: https://github.com/albertobeloni/ruby-recolor
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Recolor is a Ruby gem to convert between color models.
+test_files: []