abachrome 0.1.0

data/lib/abachrome/color_mixins/lighten.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module ColorMixins
+    module Lighten
+      def lighten(amount = 0.1)
+        amount = AbcDecimal(amount)
+        oklab = to_oklab
+        l, a, b = oklab.coordinates
+
+        new_l = l + amount
+        new_l = AbcDecimal("1.0") if new_l > 1
+        new_l = AbcDecimal("0.0") if new_l.negative?
+
+        Color.new(
+          ColorSpace.find(:oklab),
+          [new_l, a, b],
+          alpha
+        )
+      end
+
+      def lighten!(amount = 0.1)
+        lightened = lighten(amount)
+        @color_space = lightened.color_space
+        @coordinates = lightened.coordinates
+        @alpha = lightened.alpha
+        self
+      end
+
+      def darken(amount = 0.1)
+        lighten(-amount)
+      end
+
+      def darken!(amount = 0.1)
+        lighten!(-amount)
+      end
+    end
+  end
+end

data/lib/abachrome/color_mixins/to_colorspace.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module ColorMixins
+    module ToColorspace
+      def to_color_space(target_space)
+        return self if color_space == target_space
+
+        Converter.convert(self, target_space.name)
+      end
+
+      def to_color_space!(target_space)
+        unless color_space == target_space
+          converted = to_color_space(target_space)
+          @color_space = converted.color_space
+          @coordinates = converted.coordinates
+        end
+        self
+      end
+
+      def convert_to(space_name)
+        to_color_space(ColorSpace.find(space_name))
+      end
+
+      def convert_to!(space_name)
+        to_color_space!(ColorSpace.find(space_name))
+      end
+
+      def in_color_space(space_name)
+        convert_to(space_name)
+      end
+
+      def in_color_space!(space_name)
+        convert_to!(space_name)
+      end
+    end
+  end
+end

data/lib/abachrome/color_mixins/to_lrgb.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../converter"
+
+module Abachrome
+  module ColorMixins
+    module ToLrgb
+      def to_lrgb
+        return self if color_space.name == :lrgb
+
+        Converter.convert(self, :lrgb)
+      end
+
+      def to_lrgb!
+        unless color_space.name == :lrgb
+          lrgb_color = to_lrgb
+          @color_space = lrgb_color.color_space
+          @coordinates = lrgb_color.coordinates
+        end
+        self
+      end
+
+      def lred
+        to_lrgb.coordinates[0]
+      end
+
+      def lgreen
+        to_lrgb.coordinates[1]
+      end
+
+      def lblue
+        to_lrgb.coordinates[2]
+      end
+
+      def lrgb_values
+        to_lrgb.coordinates
+      end
+
+      def rgb_array
+        to_rgb.coordinates.map { |c| (c * 255).round.clamp(0, 255) }
+      end
+
+      def rgb_hex
+        r, g, b = rgb_array
+        format("#%02x%02x%02x", r, g, b)
+      end
+    end
+  end
+end

data/lib/abachrome/color_mixins/to_oklab.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../converter"
+
+module Abachrome
+  module ColorMixins
+    module ToOklab
+      def to_oklab
+        return self if color_space.name == :oklab
+
+        Converter.convert(self, :oklab)
+      end
+
+      def to_oklab!
+        unless color_space.name == :oklab
+          oklab_color = to_oklab
+          @color_space = oklab_color.color_space
+          @coordinates = oklab_color.coordinates
+        end
+        self
+      end
+
+      def lightness
+        to_oklab.coordinates[0]
+      end
+
+      def l
+        to_oklab.coordinates[0]
+      end
+
+      def a
+        to_oklab.coordinates[1]
+      end
+
+      def b
+        to_oklab.coordinates[2]
+      end
+
+      def oklab_values
+        to_oklab.coordinates
+      end
+
+      def oklab_array
+        to_oklab.coordinates
+      end
+    end
+  end
+end

data/lib/abachrome/color_mixins/to_oklch.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module ColorMixins
+    module ToOklch
+      def to_oklch
+        return self if color_space.name == :oklch
+
+        if color_space.name == :oklab
+          Converters::OklabToOklch.convert(self)
+        else
+          # For other color spaces, convert to OKLab first
+          oklab_color = to_oklab
+          Converters::OklabToOklch.convert(oklab_color)
+        end
+      end
+
+      def to_oklch!
+        unless color_space.name == :oklch
+          oklch_color = to_oklch
+          @color_space = oklch_color.color_space
+          @coordinates = oklch_color.coordinates
+        end
+        self
+      end
+
+      def lightness
+        to_oklch.coordinates[0]
+      end
+
+      def chroma
+        to_oklch.coordinates[1]
+      end
+
+      def hue
+        to_oklch.coordinates[2]
+      end
+
+      def oklch_values
+        to_oklch.coordinates
+      end
+
+      def oklch_array
+        to_oklch.coordinates
+      end
+    end
+  end
+end

data/lib/abachrome/color_mixins/to_srgb.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../converter"
+
+module Abachrome
+  module ColorMixins
+    module ToSrgb
+      def to_srgb
+        return self if color_space.name == :srgb
+
+        Converter.convert(self, :srgb)
+      end
+
+      def to_rgb
+        # assume they mean srgb
+        to_srgb
+      end
+
+      def to_srgb!
+        unless color_space.name == :srgb
+          srgb_color = to_srgb
+          @color_space = srgb_color.color_space
+          @coordinates = srgb_color.coordinates
+        end
+        self
+      end
+
+      def to_rgb!
+        # assume they mean srgb
+        to_srgb!
+      end
+
+      def red
+        to_srgb.coordinates[0]
+      end
+
+      def green
+        to_srgb.coordinates[1]
+      end
+
+      def blue
+        to_srgb.coordinates[2]
+      end
+
+      def srgb_values
+        to_srgb.coordinates
+      end
+
+      def rgb_values
+        to_srgb.coordinates
+      end
+
+      def rgb_array
+        to_srgb.coordinates.map { |c| (c * 255).round.clamp(0, 255) }
+      end
+
+      def rgb_hex
+        r, g, b = rgb_array
+        format("#%02x%02x%02x", r, g, b)
+      end
+    end
+  end
+end

data/lib/abachrome/color_models/hsv.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module ColorModels
+    class HSV < Base
+      #
+      # Internally, we use 0..1.0 values for hsv, unlike the standard 0..360, 0..255, 0..255.
+      #
+      # Values can be converted for output.
+      #
+
+      register :hsv, "HSV", %w[hue saturation value]
+
+      def valid_coordinates?(coordinates)
+        h, s, v = coordinates
+        h >= 0 && h <= 1.0 &&
+          s >= 0 && s <= 1.0 &&
+          v >= 0 && v <= 1.0
+      end
+    end
+  end
+end

data/lib/abachrome/color_models/oklab.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module ColorModels
+    class Oklab
+    end
+  end
+end
+
+ColorSpace.register(
+  :oklab,
+  "Oklab",
+  %w[l a b],
+  nil,
+  ["ok-lab"]
+)

data/lib/abachrome/color_models/oklch.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module ColorModels
+    class Oklch
+      def self.normalize(l, c, h)
+        l = AbcDecimal(l)
+        c = AbcDecimal(c)
+        h = AbcDecimal(h)
+
+        # Normalize hue to 0-360 range
+        h -= 360 while h >= 360
+        h += 360 while h.negative?
+
+        # Normalize lightness and chroma to 0-1 range
+        l = l.clamp(0, 1)
+        c = c.clamp(0, 1)
+
+        [l, c, h]
+      end
+
+      def self.to_oklab(l, c, h)
+        # Convert OKLCH to OKLab
+        h_rad = h * Math::PI / 180
+        a = c * Math.cos(h_rad)
+        b = c * Math.sin(h_rad)
+        [l, a, b]
+      end
+
+      def self.from_oklab(l, a, b)
+        # Convert OKLab to OKLCH
+        c = Math.sqrt((a * a) + (b * b))
+        h = Math.atan2(b, a) * 180 / Math::PI
+        h += 360 if h.negative?
+        [l, c, h]
+      end
+    end
+  end
+end
+
+ColorSpace.register(
+  :oklch,
+  "OKLCh",
+  %w[lightness chroma hue],
+  nil,
+  ["ok-lch"]
+)

data/lib/abachrome/color_models/rgb.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module ColorModels
+    class RGB
+      class << self
+        def normalize(r, g, b)
+          [r, g, b].map do |value|
+            case value
+            when String
+              if value.end_with?("%")
+                AbcDecimal(value.chomp("%")) / AbcDecimal(100)
+              else
+                AbcDecimal(value) / AbcDecimal(255)
+              end
+            when Numeric
+              if value > 1
+                AbcDecimal(value) / AbcDecimal(255)
+              else
+                AbcDecimal(value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/abachrome/color_space.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Abachrome
+  class ColorSpace
+    class << self
+      def registry
+        @registry ||= {}
+      end
+
+      def register(name, &block)
+        registry[name.to_sym] = new(name, &block)
+      end
+
+      def alias(name, aliased_name)
+        registry[aliased_name.to_sym] = registry[name.to_sym]
+      end
+
+      def find(name)
+        registry[name.to_sym] or raise ArgumentError, "Unknown color space: #{name}"
+      end
+    end
+
+    attr_reader :name, :coordinates, :white_point, :color_model
+
+    def initialize(name)
+      @name = name.to_sym
+      yield self if block_given?
+    end
+
+    def coordinates=(*coords)
+      @coordinates = coords.flatten
+    end
+
+    def white_point=(point)
+      @white_point = point.to_sym
+    end
+
+    def color_model=(model)
+      @color_model = model.to_sym
+    end
+
+    def ==(other)
+      return false unless other.is_a?(ColorSpace)
+
+      name == other.name
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      name.hash
+    end
+
+    def id
+      name
+    end
+  end
+
+  ColorSpace.register(:srgb) do |s|
+    s.coordinates = %i[red green blue]
+    s.white_point = :D65
+    s.color_model = :srgb
+  end
+  ColorSpace.alias(:srgb, :rgb)
+
+  ColorSpace.register(:lrgb) do |s|
+    s.coordinates = %i[red green blue]
+    s.white_point = :D65
+    s.color_model = :lrgb
+  end
+
+  ColorSpace.register(:hsl) do |s|
+    s.coordinates = %i[hue saturation lightness]
+    s.white_point = :D65
+    s.color_model = :hsl
+  end
+
+  ColorSpace.register(:lab) do |s|
+    s.coordinates = %i[lightness a b]
+    s.white_point = :D65
+    s.color_model = :lab
+  end
+
+  ColorSpace.register(:oklab) do |s|
+    s.coordinates = %i[lightness a b]
+    s.white_point = :D65
+    s.color_model = :oklab
+  end
+
+  ColorSpace.register(:oklch) do |s|
+    s.coordinates = %i[lightness chroma hue]
+    s.white_point = :D65
+    s.color_model = :oklch
+  end
+end

data/lib/abachrome/converter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Abachrome
+  class Converter
+    class << self
+      def registry
+        @registry ||= {}
+      end
+
+      def register(from_space, to_space, converter_class)
+        registry[[from_space.to_s, to_space.to_s]] = converter_class
+      end
+
+      def convert(color, to_space_name)
+        to_space = ColorSpace.find(to_space_name)
+        return color if color.color_space == to_space
+
+        # convert model first
+        to_model = to_space.color_model
+        converter = find_converter(color.color_space.color_model, to_model.to_s)
+        raise "No converter found from #{color.color_space.color_model} to #{to_model}" unless converter
+
+        converter.convert(color)
+      end
+
+      # Automatically register all converters in the Converters namespace
+      def register_all_converters
+        Converters.constants.each do |const_name|
+          const = Converters.const_get(const_name)
+          next unless const.is_a?(Class)
+
+          # Parse from_space and to_space from class name (e.g., LrgbToOklab)
+          next unless const_name.to_s =~ /^(.+)To(.+)$/
+
+          from_space = ::Regexp.last_match(1).downcase.to_sym
+          to_space = ::Regexp.last_match(2).downcase.to_sym
+
+          # Register the converter
+          register(from_space, to_space, const)
+        end
+      end
+
+      private
+
+      def find_converter(from_space_name, to_space_name)
+        registry[[from_space_name.to_s, to_space_name.to_s]]
+      end
+    end
+  end
+
+  # Load all converter files
+  converters_path = File.join(__dir__, "converters", "*.rb")
+  Dir[converters_path].each do |file|
+    require file
+  end
+
+  # Auto-register all converters
+  Converter.register_all_converters
+end

data/lib/abachrome/converters/base.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module Converters
+    class Base
+      attr_reader :from_space, :to_space
+
+      def initialize(from_space, to_space)
+        @from_space = from_space
+        @to_space = to_space
+      end
+
+      def convert(color)
+        raise NotImplementedError, "Subclasses must implement #convert"
+      end
+
+      def self.raise_unless(color, model)
+        return if color.color_space.color_model == model
+
+        raise "#{color} is #{color.color_space.color_model}), expecting #{model}"
+      end
+
+      def can_convert?(color)
+        color.color_space == from_space
+      end
+
+      def self.register(from_space_id, to_space_id, converter_class)
+        @converters ||= {}
+        @converters[[from_space_id, to_space_id]] = converter_class
+      end
+
+      def self.find_converter(from_space_id, to_space_id)
+        @converters ||= {}
+        @converters[[from_space_id, to_space_id]]
+      end
+
+      def self.convert(color, to_space)
+        converter_class = find_converter(color.color_space.id, to_space.id)
+        unless converter_class
+          raise ConversionError,
+                "No converter found from #{color.color_space.name} to #{to_space.name}"
+        end
+
+        converter = converter_class.new(color.color_space, to_space)
+        converter.convert(color)
+      end
+
+      private
+
+      def validate_color!(color)
+        return if can_convert?(color)
+
+        raise ArgumentError, "Cannot convert color from #{color.color_space.name} (expected #{from_space.name})"
+      end
+    end
+  end
+end

data/lib/abachrome/converters/lrgb_to_oklab.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module Converters
+    class LrgbToOklab < Abachrome::Converters::Base
+      def self.convert(rgb_color)
+        raise_unless rgb_color, :lrgb
+
+        r, g, b = rgb_color.coordinates.map { |_| AbcDecimal(_) }
+
+        l = (AD("0.41222147079999993") * r) + (AD("0.5363325363") * g) + (AD("0.0514459929") * b)
+        m = (AD("0.2119034981999999") * r) + (AD("0.680699545099999") * g) + (AD("0.1073969566") * b)
+        s = (AD("0.08830246189999998") * r) + (AD("0.2817188376") * g) + (AD("0.6299787005000002") * b)
+
+        l_ = AbcDecimal(l)**Rational(1, 3)
+        m_ = AbcDecimal(m)**Rational(1, 3)
+        s_ = AbcDecimal(s)**Rational(1, 3)
+
+        lightness = (AD("0.2104542553") * l_) + (AD("0.793617785") * m_) - (AD("0.0040720468") * s_)
+        a         = (AD("1.9779984951") * l_) - (AD("2.4285922050") * m_) + (AD("0.4505937099") * s_)
+        b         = (AD("0.0259040371") * l_) + (AD("0.7827717662") * m_) - (AD("0.8086757660") * s_)
+
+        Color.new(ColorSpace.find(:oklab), [lightness, a, b], rgb_color.alpha)
+      end
+    end
+  end
+end

data/lib/abachrome/converters/lrgb_to_srgb.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module Converters
+    class LrgbToSrgb < Abachrome::Converters::Base
+      def self.convert(lrgb_color)
+        raise_unless lrgb_color, :lrgb
+        r, g, b = lrgb_color.coordinates.map { |c| to_srgb(AbcDecimal(c)) }
+
+        output_coords = [r, g, b]
+
+        Color.new(
+          ColorSpace.find(:srgb),
+          output_coords,
+          lrgb_color.alpha
+        )
+      end
+
+      def self.to_srgb(v)
+        v_abs = v.abs
+        v_sign = v.negative? ? -1 : 1
+        if v_abs <= AD("0.0031308")
+          v * AD("12.92")
+        else
+          v_sign * ((AD("1.055") * (v_abs**Rational(1.0, 2.4))) - AD("0.055"))
+        end
+      end
+    end
+  end
+end