abachrome 0.1.0

data/lib/abachrome/outputs/css.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative "../color"
+require_relative "../color_space"
+
+module Abachrome
+  module Outputs
+    class CSS
+      def self.format(color, gamut: nil, companding: nil)
+        rgb_color = color.to_rgb
+        r, g, b = rgb_color.coordinates
+        a = rgb_color.alpha
+
+        # Apply gamut mapping if provided
+        r, g, b = gamut.map([r, g, b]) if gamut
+
+        # Apply companding if provided
+        if companding
+          r = companding.call(r)
+          g = companding.call(g)
+          b = companding.call(b)
+        end
+
+        # Convert to 8-bit values
+        r = (r * 255).round
+        g = (g * 255).round
+        b = (b * 255).round
+
+        # Format based on alpha value
+        return Kernel.format("rgba(%d, %d, %d, %.3f)", r, g, b, a) unless a == AbcDecimal.new("1.0")
+        return Kernel.format("#%02x%02x%02x", r, g, b) unless r == g && g == b
+
+        # Use shortened hex format for grayscale
+        hex = Kernel.format("%02x", r)
+        "##{hex}#{hex}#{hex}"
+      end
+
+      def self.format_hex(color, gamut: nil, companding: nil)
+        rgb_color = color.to_rgb
+        r, g, b = rgb_color.coordinates
+        a = rgb_color.alpha
+
+        # Apply gamut mapping if provided
+        r, g, b = gamut.map([r, g, b]) if gamut
+
+        # Apply companding if provided
+        if companding
+          r = companding.call(r)
+          g = companding.call(g)
+          b = companding.call(b)
+        end
+
+        r = (r * 255).round
+        g = (g * 255).round
+        b = (b * 255).round
+
+        if a == AbcDecimal.new("1.0")
+          Kernel.format("#%02x%02x%02x", r, g, b)
+        else
+          a = (a * 255).round
+          Kernel.format("#%02x%02x%02x%02x", r, g, b, a)
+        end
+      end
+
+      def self.format_rgb(color, gamut: nil, companding: nil)
+        rgb_color = color.to_rgb
+        r, g, b = rgb_color.coordinates
+        a = rgb_color.alpha
+
+        # Apply gamut mapping if provided
+        r, g, b = gamut.map([r, g, b]) if gamut
+
+        # Apply companding if provided
+        if companding
+          r = companding.call(r)
+          g = companding.call(g)
+          b = companding.call(b)
+        end
+
+        r = (r * 255).round
+        g = (g * 255).round
+        b = (b * 255).round
+
+        if a == AbcDecimal.new("1.0")
+          Kernel.format("rgb(%d, %d, %d)", r, g, b)
+        else
+          Kernel.format("rgba(%d, %d, %d, %.3f)", r, g, b, a)
+        end
+      end
+
+      def self.format_oklab(color, gamut: nil, companding: nil, precision: 3)
+        oklab_color = color.to_oklab
+        l, a, b = oklab_color.coordinates
+        alpha = oklab_color.alpha
+
+        # Apply gamut mapping if provided
+        l, a, b = gamut.map([l, a, b]) if gamut
+
+        # Apply companding if provided
+        if companding
+          l = companding.call(l)
+          a = companding.call(a)
+          b = companding.call(b)
+        end
+
+        # Format with appropriate precision
+        format_string = "%.#{precision}f %.#{precision}f %.#{precision}f"
+
+        if alpha == AbcDecimal.new("1.0")
+          Kernel.format("oklab(#{format_string})", l, a, b)
+        else
+          Kernel.format("oklab(#{format_string} / %.#{precision}f)", l, a, b, alpha)
+        end
+      end
+    end
+  end
+end

data/lib/abachrome/palette.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Abachrome
+  class Palette
+    attr_reader :colors
+
+    def initialize(colors = [])
+      @colors = colors.map { |c| c.is_a?(Color) ? c : Color.from_hex(c.to_s) }
+    end
+
+    def add(color)
+      color = Color.from_hex(color.to_s) unless color.is_a?(Color)
+      @colors << color
+      self
+    end
+
+    alias << add
+
+    def remove(color)
+      @colors.delete(color)
+      self
+    end
+
+    def clear
+      @colors.clear
+      self
+    end
+
+    def size
+      @colors.size
+    end
+
+    def empty?
+      @colors.empty?
+    end
+
+    def each(&block)
+      @colors.each(&block)
+    end
+    def each_with_index(&block)
+      @colors.each_with_index(&block)
+    end
+
+    def map(&block)
+      self.class.new(@colors.map(&block))
+    end
+
+    def to_a
+      @colors.dup
+    end
+
+    def [](index)
+      @colors[index]
+    end
+
+    def slice(start, length = nil)
+      new_colors = length ? @colors[start, length] : @colors[start]
+      self.class.new(new_colors)
+    end
+
+    def first
+      @colors.first
+    end
+
+    def last
+      @colors.last
+    end
+
+    def sort_by_lightness
+      self.class.new(@colors.sort_by(&:lightness))
+    end
+
+    def sort_by_saturation
+      self.class.new(@colors.sort_by { |c| c.to_oklab.coordinates[1] })
+    end
+
+    def blend_all(amount = 0.5)
+      return nil if empty?
+
+      result = first
+      @colors[1..].each do |color|
+        result = result.blend(color, amount)
+      end
+      result
+    end
+
+    def average
+      return nil if empty?
+
+      oklab_coords = @colors.map(&:to_oklab).map(&:coordinates)
+      avg_coords = oklab_coords.reduce([0, 0, 0]) do |sum, coords|
+        [sum[0] + coords[0], sum[1] + coords[1], sum[2] + coords[2]]
+      end
+      avg_coords.map! { |c| c / size }
+
+      Color.new(
+        ColorSpace.find(:oklab),
+        avg_coords,
+        @colors.map(&:alpha).sum / size
+      )
+    end
+
+    def to_css(format: :hex)
+      to_a.map do |color|
+        case format
+        when :hex
+          Outputs::CSS.format_hex(color)
+        when :rgb
+          Outputs::CSS.format_rgb(color)
+        when :oklab
+          Outputs::CSS.format_oklab(color)
+        else
+          Outputs::CSS.format(color)
+        end
+      end
+    end
+
+    def inspect
+      "#<#{self.class} colors=#{@colors.map(&:to_s)}>"
+    end
+
+    mixins_path = File.join(__dir__, "palette_mixins", "*.rb")
+    Dir[mixins_path].each do |file|
+      require file
+      mixin_name = File.basename(file, ".rb")
+      inflector = Dry::Inflector.new
+      mixin_module = Abachrome::PaletteMixins.const_get(inflector.camelize(mixin_name))
+      include mixin_module
+    end
+  end
+end

data/lib/abachrome/palette_mixins/interpolate.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module PaletteMixins
+    module Interpolate
+      def interpolate(count_between = 1)
+        return self if count_between < 1 || size < 2
+
+        new_colors = []
+        @colors.each_cons(2) do |color1, color2|
+          new_colors << color1
+          step = AbcDecimal("1.0") / AbcDecimal(count_between + 1)
+
+          (1..count_between).each do |i|
+            amount = step * i
+            new_colors << color1.blend(color2, amount)
+          end
+        end
+        new_colors << last
+
+        self.class.new(new_colors)
+      end
+
+      def interpolate!(count_between = 1)
+        interpolated = interpolate(count_between)
+        @colors = interpolated.colors
+        self
+      end
+    end
+  end
+end

data/lib/abachrome/palette_mixins/resample.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module PaletteMixins
+    module Resample
+      def resample(new_size)
+        return self if new_size == size || empty?
+        return self.class.new([@colors.first]) if new_size == 1
+
+        step = (size - 1).to_f / (new_size - 1)
+
+        self.class.new(
+          (0...new_size).map do |i|
+            index = i * step
+            lower_index = index.floor
+            upper_index = [lower_index + 1, size - 1].min
+
+            if lower_index == upper_index
+              @colors[lower_index]
+            else
+              fraction = index - lower_index
+              @colors[lower_index].blend(@colors[upper_index], fraction)
+            end
+          end
+        )
+      end
+
+      def resample!(new_size)
+        resampled = resample(new_size)
+        @colors = resampled.colors
+        self
+      end
+
+      def expand(new_size)
+        raise ArgumentError, "New size must be larger than current size" if new_size <= size
+
+        resample(new_size)
+      end
+
+      def expand!(new_size)
+        raise ArgumentError, "New size must be larger than current size" if new_size <= size
+
+        resample!(new_size)
+      end
+
+      def reduce(new_size)
+        raise ArgumentError, "New size must be smaller than current size" if new_size >= size
+
+        resample(new_size)
+      end
+
+      def reduce!(new_size)
+        raise ArgumentError, "New size must be smaller than current size" if new_size >= size
+
+        resample!(new_size)
+      end
+    end
+  end
+end

data/lib/abachrome/palette_mixins/stretch_luminance.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module PaletteMixins
+    module StretchLuminance
+      def stretch_luminance(new_min: 0.0, new_max: 1.0)
+        return self if empty?
+
+        new_min = AbcDecimal(new_min)
+        new_max = AbcDecimal(new_max)
+
+        oklab_colors = @colors.map(&:to_oklab)
+        current_min = oklab_colors.map { |c| c.coordinates[0] }.min
+        current_max = oklab_colors.map { |c| c.coordinates[0] }.max
+
+        range = current_max - current_min
+        new_range = new_max - new_min
+
+        self.class.new(
+          oklab_colors.map do |color|
+            l, a, b = color.coordinates
+            scaled_l = if range.zero?
+                         new_min
+                       else
+                         new_min + ((l - current_min) * new_range / range)
+                       end
+
+            Color.new(
+              ColorSpace.find(:oklab),
+              [scaled_l, a, b],
+              color.alpha
+            )
+          end
+        )
+      end
+
+      def stretch_luminance!(new_min: 0.0, new_max: 1.0)
+        stretched = stretch_luminance(new_min: new_min, new_max: new_max)
+        @colors = stretched.colors
+        self
+      end
+
+      def normalize_luminance
+        stretch_luminance(new_min: 0.0, new_max: 1.0)
+      end
+
+      def normalize_luminance!
+        stretch_luminance!(new_min: 0.0, new_max: 1.0)
+      end
+
+      def compress_luminance(amount = 0.5)
+        amount = AbcDecimal(amount)
+        mid_point = AbcDecimal("0.5")
+        stretch_luminance(
+          new_min: mid_point - (mid_point * amount),
+          new_max: mid_point + (mid_point * amount)
+        )
+      end
+
+      def compress_luminance!(amount = 0.5)
+        amount = AbcDecimal(amount)
+        mid_point = AbcDecimal("0.5")
+        stretch_luminance!(
+          new_min: mid_point - (mid_point * amount),
+          new_max: mid_point + (mid_point * amount)
+        )
+      end
+    end
+  end
+end

data/lib/abachrome/parsers/hex.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module Parsers
+    class Hex
+      HEX_PATTERN = /^#?([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{4}|[0-9A-Fa-f]{8})$/
+
+      def self.parse(input)
+        hex = input.gsub(/^#/, "")
+        return nil unless hex.match?(HEX_PATTERN)
+
+        case hex.length
+        when 3
+          parse_short_hex(hex)
+        when 4
+          parse_short_hex_with_alpha(hex)
+        when 6
+          parse_full_hex(hex)
+        when 8
+          parse_full_hex_with_alpha(hex)
+        end
+      end
+
+      def self.parse_short_hex(hex)
+        r, g, b = hex.chars.map { |c| (c + c).to_i(16) }
+        Color.from_rgb(r / 255.0, g / 255.0, b / 255.0)
+      end
+
+      def self.parse_short_hex_with_alpha(hex)
+        r, g, b, a = hex.chars.map { |c| (c + c).to_i(16) }
+        Color.from_rgb(r / 255.0, g / 255.0, b / 255.0, a / 255.0)
+      end
+
+      def self.parse_full_hex(hex)
+        r = hex[0, 2].to_i(16)
+        g = hex[2, 2].to_i(16)
+        b = hex[4, 2].to_i(16)
+        Color.from_rgb(r / 255.0, g / 255.0, b / 255.0)
+      end
+
+      def self.parse_full_hex_with_alpha(hex)
+        r = hex[0, 2].to_i(16)
+        g = hex[2, 2].to_i(16)
+        b = hex[4, 2].to_i(16)
+        a = hex[6, 2].to_i(16)
+        Color.from_rgb(r / 255.0, g / 255.0, b / 255.0, a / 255.0)
+      end
+    end
+  end
+end

data/lib/abachrome/to_abcd.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module ToAbcd
+    def to_abcd
+      AbcDecimal.new(self)
+    end
+  end
+end
+
+[Numeric, String, Rational].each do |klass|
+  klass.include(Abachrome::ToAbcd)
+end

data/lib/abachrome/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Abachrome
+  VERSION = "0.1.0"
+end

data/lib/abachrome.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative "abachrome/to_abcd"
+
+module Abachrome
+  module_function
+
+  autoload :AbcDecimal, "abachrome/abc_decimal"
+  autoload :Color, "abachrome/color"
+  autoload :Palette, "abachrome/palette"
+  autoload :ColorSpace, "abachrome/color_space"
+  autoload :Converter, "abachrome/converter"
+  autoload :Gamut, "abachrome/gamut/base"
+  autoload :ToAbcd, "abachrome/to_abcd"
+  autoload :VERSION, "abachrome/version"
+
+  module ColorModels
+    autoload :HSV, "abachrome/color_models/hsv"
+    autoload :Oklab, "abachrome/color_models/oklab"
+    autoload :RGB, "abachrome/color_models/rgb"
+  end
+
+  module ColorMixins
+    autoload :ToLrgb, "abachrome/color_mixins/to_lrgb"
+    autoload :ToOklab, "abachrome/color_mixins/to_oklab"
+  end
+
+  module Converters
+    autoload :Base, "abachrome/converters/base"
+    autoload :LrgbToOklab, "abachrome/converters/lrgb_to_oklab"
+    autoload :OklabToLrgb, "abachrome/converters/oklab_to_lrgb"
+  end
+
+  module Gamut
+    autoload :P3, "abachrome/gamut/p3"
+    autoload :Rec2020, "abachrome/gamut/rec2020"
+    autoload :SRGB, "abachrome/gamut/srgb"
+  end
+
+  module Illuminants
+    autoload :Base, "abachrome/illuminants/base"
+    autoload :D50, "abachrome/illuminants/d50"
+    autoload :D55, "abachrome/illuminants/d55"
+    autoload :D65, "abachrome/illuminants/d65"
+    autoload :D75, "abachrome/illuminants/d75"
+  end
+
+  module Named
+    autoload :CSS, "abachrome/named/css"
+  end
+
+  module Outputs
+    autoload :CSS, "abachrome/outputs/css"
+  end
+
+  module Parsers
+    autoload :Hex, "abachrome/parsers/hex"
+  end
+
+  def create_color(space_name, *coordinates, alpha: 1.0)
+    space = ColorSpace.find(space_name)
+    Color.new(space, coordinates, alpha)
+  end
+
+  def from_rgb(r, g, b, alpha = 1.0)
+    Color.from_rgb(r, g, b, alpha)
+  end
+
+  def from_oklab(l, a, b, alpha = 1.0)
+    Color.from_oklab(l, a, b, alpha)
+  end
+
+  def from_oklch(l, a, b, alpha = 1.0)
+    Color.from_oklch(l, a, b, alpha)
+  end
+
+  def from_hex(hex_str)
+    Parsers::Hex.parse(hex_str)
+  end
+
+  def from_name(color_name)
+    rgb_values = Named::CSS::ColorNames[color_name.downcase]
+    return nil unless rgb_values
+
+    from_rgb(*rgb_values.map { |v| v / 255.0 })
+  end
+
+  def convert(color, to_space)
+    Converter.convert(color, to_space)
+  end
+
+  def register_color_space(name, &block)
+    ColorSpace.register(name, &block)
+  end
+
+  def register_converter(from_space, to_space, converter)
+    Converter.register(from_space, to_space, converter)
+  end
+end