abachrome 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 88fab17313d84aca8190acb8c108af84d1129ce9e240353e2afec2225fc5aa37
+  data.tar.gz: f98569f28bf4a1fa967f43bc8538de967e7dfa34f40f22749099b51b8b7512ac
+SHA512:
+  metadata.gz: 1df4f29f6700b0488656b3a7c7dc22a1aa72cfab8d6a11cfc89363acd57488a39e9ded2d79f397c2727e7cbb5a2b203f41975cdbc891de3028435b3d40be1915
+  data.tar.gz: d31cb69b1412ab7e5c06349ce2e44b9b1ecf1324d2b862d26e19adbf496bfeeec0c1195382bf5f4092d0fe12407e4d9d9024c7fe1065e52b3b353f94e55a79a4

data/.rubocop.yml

@@ -0,0 +1,10 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-02-09
+
+- Initial release

data/README.md

@@ -0,0 +1,99 @@
+# Abachrome
+
+Abachrome is a Ruby gem for parsing, manipulating, and managing colors. It provides a robust set of tools for working with various color formats including hex, RGB, HSL, and named colors.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'abachrome'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install abachrome
+```
+
+## Usage
+
+### Basic Color Creation
+
+```ruby
+# Create colors in different ways
+color = Abachrome.from_rgb(1.0, 0.0, 0.0)           # Red using RGB values
+color = Abachrome.from_hex('#FF0000')               # Red using hex
+color = Abachrome.from_name('red')                  # Red using CSS color name
+
+# Create color with alpha
+color = Abachrome.from_rgb(1.0, 0.0, 0.0, 0.5)     # Semi-transparent red
+```
+
+### Color Space Conversion
+
+```ruby
+# Convert between color spaces
+rgb_color = Abachrome.from_rgb(1.0, 0.0, 0.0)
+oklab_color = rgb_color.to_oklab                    # Convert to Oklab
+rgb_again = oklab_color.to_rgb                      # Convert back to RGB
+```
+
+### Color Output Formats
+
+```ruby
+color = Abachrome.from_rgb(1.0, 0.0, 0.0)
+
+# Different output formats
+color.rgb_hex                                       # => "#ff0000"
+Abachrome::Outputs::CSS.format(color)              # => "#ff0000"
+Abachrome::Outputs::CSS.format_rgb(color)          # => "rgb(255, 0, 0)"
+```
+
+### Working with Color Gamuts
+
+```ruby
+# Check if color is within gamut
+srgb_gamut = Abachrome::Gamut::SRGB.new
+color = Abachrome.from_rgb(1.2, -0.1, 0.5)
+mapped_color = srgb_gamut.map(color.coordinates)    # Map color to gamut
+```
+
+## Features
+
+- Support for multiple color spaces (RGB, HSL, Lab, Oklab)
+- Color space conversion
+- Gamut mapping
+- CSS color parsing and formatting
+- Support for CSS named colors
+- High-precision color calculations using BigDecimal
+- Alpha channel support
+
+## Requirements
+
+- Ruby >= 3.0.0
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/durableprogramming/abachrome.
+
+# Acknowledgement
+
+We'd like to thank the excellent Color.js and culori color libraries, which helped inspire this project and
+inform its design.

data/demos/ncurses/plasma.rb

@@ -0,0 +1,124 @@
+require 'bundler/setup'
+
+require "curses"
+require "abachrome"
+
+DELAY = 0.0016 
+PLASMA_SCALE = 0.02
+TIME_SCALE = 2.0
+
+# Generate base hue for the palette
+base_hue = rand(0..360)
+base_color = Abachrome.from_oklch(0.5, 0.2, base_hue)
+
+# Create 255 shades palette interpolating from black to base_color to white
+black = Abachrome.from_rgb(0, 0, 0)
+white = Abachrome.from_rgb(1, 1, 1)
+palette = Abachrome::Palette.new([black, base_color, white])
+palette = palette.interpolate(32)
+
+def plasma(x, y, t)
+  x_scaled = x * PLASMA_SCALE
+  y_scaled = y * PLASMA_SCALE
+  t_scaled = t * TIME_SCALE
+
+  value = Math.sin(x_scaled) + Math.sin(y_scaled) +
+          Math.sin(x_scaled + y_scaled + t_scaled) +
+          Math.sin(Math.sqrt((x_scaled * x_scaled + y_scaled * y_scaled)) + t_scaled)
+
+  # Normalize to 0..1 range
+  (value + 4) / 8
+end
+
+def pick_color(value, palette)
+  normalized = (value * (palette.size - 1))
+
+  # Error diffusion dithering
+  error = normalized - normalized.floor
+  if rand < error
+    normalized.ceil
+  else
+    normalized.floor
+  end + 1
+end
+
+begin
+  require 'curses'
+
+  Curses.init_screen
+  Curses.start_color
+  Curses.curs_set(0)
+  Curses.noecho
+  Curses.cbreak
+  Curses.stdscr.nodelay = 1
+
+  total_colors = palette.size
+  bar_width = 50
+
+  Curses.setpos(Curses.lines / 2 - 1, (Curses.cols - 20) / 2)
+  Curses.addstr("Initializing colors")
+
+  Curses.use_default_colors
+  palette.each_with_index do |color, i|
+    progress = ((i + 1).to_f / total_colors * bar_width).to_i
+    
+    Curses.attron(Curses.color_pair(0)) {
+      Curses.setpos(Curses.lines / 2, (Curses.cols - bar_width) / 2)
+      Curses.addstr("[" + "#" * progress + " " * (bar_width - progress) + "]")
+      
+      Curses.setpos(Curses.lines / 2 + 1, (Curses.cols - 20) / 2)
+      percentage = ((i + 1).to_f / total_colors * 100).to_i
+      Curses.addstr("#{percentage}% complete")
+    }
+    
+    Curses.refresh
+    
+    rgb = color.rgb_array.map { |_| ((_ * 1000)/255).to_i }
+    Curses.init_color(i + 1, rgb[0], rgb[1], rgb[2])
+    Curses.init_pair(i + 1, i + 1, i + 1)
+    
+  end
+
+  Curses.setpos(Curses.lines / 2 + 2, (Curses.cols - 20) / 2)
+  Curses.addstr("Done!")
+  Curses.refresh
+
+  height = Curses.lines
+  width = Curses.cols
+  start_time = Time.now
+  frame_count = 0
+  last_fps_update = start_time
+
+  loop do
+
+    t = Time.now - start_time
+    frame_count += 1
+
+    # Update FPS counter every second
+    if Time.now - last_fps_update >= 1
+      fps = frame_count / (Time.now - last_fps_update)
+      frame_count = 0
+      last_fps_update = Time.now
+      fps_str = format("FPS: %.1f", fps.to_f)
+      Curses.setpos(height - 1, width - fps_str.length)
+      Curses.addstr(fps_str)
+      Curses.setpos(height - 1, 0)
+      Curses.addstr('Frame' +  frame_count.to_s)
+    end
+
+    height.times do |y|
+      width.times do |x|
+        value = plasma(x, y, t)
+        color_index = pick_color(value, palette)
+        Curses.setpos(y, x)
+        Curses.attron(Curses.color_pair(color_index.to_i)) { Curses.addstr("X") }
+      end
+    end
+
+    Curses.refresh
+    sleep(DELAY)
+  end
+
+ensure
+  Curses.close_screen
+end

data/devenv.lock

@@ -0,0 +1,100 @@
+{
+  "nodes": {
+    "devenv": {
+      "locked": {
+        "dir": "src/modules",
+        "lastModified": 1739172804,
+        "owner": "cachix",
+        "repo": "devenv",
+        "rev": "f8be0ed0141abab89cefb20d3d375740671fbee1",
+        "type": "github"
+      },
+      "original": {
+        "dir": "src/modules",
+        "owner": "cachix",
+        "repo": "devenv",
+        "type": "github"
+      }
+    },
+    "flake-compat": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1733328505,
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "ff81ac966bb2cae68946d5ed5fc4994f96d0ffec",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "gitignore": {
+      "inputs": {
+        "nixpkgs": [
+          "pre-commit-hooks",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1709087332,
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "rev": "637db329424fd7e46cf4185293b9cc8c88c95394",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1733477122,
+        "owner": "cachix",
+        "repo": "devenv-nixpkgs",
+        "rev": "7bd9e84d0452f6d2e63b6e6da29fe73fac951857",
+        "type": "github"
+      },
+      "original": {
+        "owner": "cachix",
+        "ref": "rolling",
+        "repo": "devenv-nixpkgs",
+        "type": "github"
+      }
+    },
+    "pre-commit-hooks": {
+      "inputs": {
+        "flake-compat": "flake-compat",
+        "gitignore": "gitignore",
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1737465171,
+        "owner": "cachix",
+        "repo": "pre-commit-hooks.nix",
+        "rev": "9364dc02281ce2d37a1f55b6e51f7c0f65a75f17",
+        "type": "github"
+      },
+      "original": {
+        "owner": "cachix",
+        "repo": "pre-commit-hooks.nix",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "devenv": "devenv",
+        "nixpkgs": "nixpkgs",
+        "pre-commit-hooks": "pre-commit-hooks"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

data/devenv.nix

@@ -0,0 +1,51 @@
+{ pkgs, lib, config, inputs, ... }:
+
+{
+  # https://devenv.sh/basics/
+  env.GREET = "devenv";
+
+  # https://devenv.sh/packages/
+  packages = [ pkgs.git pkgs.ncurses pkgs.asciinema pkgs.asciinema-agg];
+
+	languages.ruby.enable = true;
+
+  languages.javascript.enable = true;
+  languages.javascript.npm.enable = true;
+  languages.javascript.bun.enable = true;
+
+  # https://devenv.sh/languages/
+  # languages.rust.enable = true;
+
+  # https://devenv.sh/processes/
+  # processes.cargo-watch.exec = "cargo-watch";
+
+  # https://devenv.sh/services/
+  # services.postgres.enable = true;
+
+  # https://devenv.sh/scripts/
+  scripts.hello.exec = ''
+    echo hello from $GREET
+  '';
+
+  enterShell = ''
+    hello
+    git --version
+  '';
+
+  # https://devenv.sh/tasks/
+  # tasks = {
+  #   "myproj:setup".exec = "mytool build";
+  #   "devenv:enterShell".after = [ "myproj:setup" ];
+  # };
+
+  # https://devenv.sh/tests/
+  enterTest = ''
+    echo "Running tests"
+    git --version | grep --color=auto "${pkgs.git.version}"
+  '';
+
+  # https://devenv.sh/pre-commit-hooks/
+  # pre-commit.hooks.shellcheck.enable = true;
+
+  # See full reference at https://devenv.sh/reference/options/
+}

data/devenv.yaml

@@ -0,0 +1,15 @@
+# yaml-language-server: $schema=https://devenv.sh/devenv.schema.json
+inputs:
+  nixpkgs:
+    url: github:cachix/devenv-nixpkgs/rolling
+
+# If you're using non-OSS software, you can set allowUnfree to true.
+# allowUnfree: true
+
+# If you're willing to use a package that's vulnerable
+# permittedInsecurePackages:
+#  - "openssl-1.1.1w"
+
+# If you have more than one devenv you can merge them
+#imports:
+# - ./backend

data/lib/abachrome/abc_decimal.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "forwardable"
+
+module Abachrome
+  class AbcDecimal
+    extend Forwardable
+    DEFAULT_PRECISION = (ENV["ABC_DECIMAL_PRECISION"] || "24").to_i
+
+    attr_accessor :value, :precision
+
+    def_delegators :@value, :to_i, :to_f, :zero?, :nonzero?
+
+    def initialize(value, precision = DEFAULT_PRECISION)
+      @precision = precision
+      @value = case value
+               when AbcDecimal
+                 value.value
+               when BigDecimal
+                 value
+               when Rational
+                 value
+               else
+                 BigDecimal(value.to_s, precision)
+               end
+    end
+
+    def to_s
+      if @value.is_a?(Rational)
+        BigDecimal(@value, precision).to_s("F")
+      else
+        @value.to_s("F") # different behaviour than default BigDecimal
+      end
+    end
+
+    def to_f
+      @value.to_f
+    end
+
+    def self.from_string(str, precision = DEFAULT_PRECISION)
+      new(str, precision)
+    end
+
+    def self.from_rational(rational, precision = DEFAULT_PRECISION)
+      new(rational, precision)
+    end
+
+    def self.from_float(float, precision = DEFAULT_PRECISION)
+      new(float, precision)
+    end
+
+    def self.from_integer(integer, precision = DEFAULT_PRECISION)
+      new(integer, precision)
+    end
+
+    def +(other)
+      other_value = other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value
+      self.class.new(@value + other_value)
+    end
+
+    def -(other)
+      other_value = other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value
+      self.class.new(@value - other_value)
+    end
+
+    def *(other)
+      other_value = other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value
+      self.class.new(@value * other_value)
+    end
+
+    def /(other)
+      other_value = other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value
+      self.class.new(@value / other_value)
+    end
+
+    def %(other)
+      other_value = other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value
+      self.class.new(@value % other_value)
+    end
+
+    def clamp(min,max)
+      @value.clamp(AbcDecimal(min),AbcDecimal(max))
+    end
+
+    def **(other)
+      if other.is_a?(Rational)
+        self.class.new(@value**other)
+      else
+        other_value = other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value
+        self.class.new(@value**other_value)
+      end
+    end
+
+    def coerce(other)
+      [self.class.new(other), self]
+    end
+
+    def inspect
+      "#{self.class}('#{self}')"
+    end
+
+    def ==(other)
+      @value == (other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value)
+    end
+
+    def <=>(other)
+      @value <=> (other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value)
+    end
+
+    def >(other)
+      @value > (other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value)
+    end
+
+    def >=(other)
+      @value >= (other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value)
+    end
+
+    def <(other)
+      @value < (other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value)
+    end
+
+    def <=(other)
+      @value <= (other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value)
+    end
+
+    def clamp(*args)
+      AbcDecimal(@value.clamp(*args))
+    end
+
+    def round(*args)
+      AbcDecimal(@value.round(*args))
+    end
+
+    def abs(*args)
+      AbcDecimal(@value.abs(*args))
+    end
+
+    def sqrt
+      AbcDecimal(Math.sqrt(@value))
+    end
+
+    def negative?
+      @value.negative?
+    end
+
+    def self.atan2(y, x)
+      y_value = y.is_a?(AbcDecimal) ? y.value : AbcDecimal(y).value
+      x_value = x.is_a?(AbcDecimal) ? x.value : AbcDecimal(x).value
+      new(Math.atan2(y_value, x_value))
+    end
+  end
+end
+
+def AbcDecimal(*args)
+  Abachrome::AbcDecimal.new(*args)
+end
+
+def AD(*args)
+  Abachrome::AbcDecimal.new(*args)
+end

data/lib/abachrome/color.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "dry-inflector"
+require_relative "abc_decimal"
+require_relative "color_space"
+
+module Abachrome
+  class Color
+    attr_reader :color_space, :coordinates, :alpha
+
+    def initialize(color_space, coordinates, alpha = AbcDecimal("1.0"))
+      @color_space = color_space
+      @coordinates = coordinates.map { |c| AbcDecimal(c.to_s) }
+      @alpha = AbcDecimal.new(alpha.to_s)
+
+      validate_coordinates!
+    end
+
+    mixins_path = File.join(__dir__, "color_mixins", "*.rb")
+    Dir[mixins_path].each do |file|
+      require file
+      mixin_name = File.basename(file, ".rb")
+      inflector = Dry::Inflector.new
+      mixin_module = Abachrome::ColorMixins.const_get(inflector.camelize(mixin_name))
+      include mixin_module
+    end
+
+    def self.from_rgb(r, g, b, a = 1.0)
+      space = ColorSpace.find(:srgb)
+      new(space, [r, g, b], a)
+    end
+
+    def self.from_oklab(l, a, b, alpha = 1.0)
+      space = ColorSpace.find(:oklab)
+      new(space, [l, a, b], alpha)
+    end
+
+    def self.from_oklch(l, c, h, alpha = 1.0)
+      space = ColorSpace.find(:oklch)
+      new(space, [l, c, h], alpha)
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Color)
+
+      color_space == other.color_space &&
+        coordinates == other.coordinates &&
+        alpha == other.alpha
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      [color_space, coordinates, alpha].map(&:to_s).hash
+    end
+
+    def to_s
+      coord_str = coordinates.map { |c| c.to_f.round(3) }.join(", ")
+      alpha_str = alpha == AbcDecimal.new("1.0") ? "" : ", #{alpha.to_f.round(3)}"
+      "#{color_space.name}(#{coord_str}#{alpha_str})"
+    end
+
+    private
+
+    def validate_coordinates!
+      return if coordinates.size == color_space.coordinates.size
+
+      raise ArgumentError,
+            "Expected #{color_space.coordinates.size} coordinates for #{color_space.name}, got #{coordinates.size}"
+    end
+  end
+end

data/lib/abachrome/color_mixins/blend.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module ColorMixins
+    module Blend
+      def blend(other, amount = 0.5, target_color_space: nil)
+        amount = AbcDecimal(amount)
+
+        source = target_color_space ? to_color_space(target_color_space) : self
+        other = other.to_color_space(source.color_space)
+
+        l1, a1, b1 = coordinates.map { |_| AbcDecimal(_) }
+        l2, a2, b2 = other.coordinates.map { |_| AbcDecimal(_) }
+
+        blended_l = (AbcDecimal(1 - amount) * l1)     + (AbcDecimal(amount) * l2)
+        blended_a = (AbcDecimal(1 - amount) * a1)     + (AbcDecimal(amount) * a2)
+        blended_b = (AbcDecimal(1 - amount) * b1)     + (AbcDecimal(amount) * b2)
+
+        blended_alpha = alpha + ((other.alpha - alpha) * amount)
+
+        Color.new(
+          color_space,
+          [blended_l, blended_a, blended_b],
+          blended_alpha
+        )
+      end
+
+      def blend!(other, amount = 0.5)
+        blended = blend(other, amount)
+        @color_space = blended.color_space
+        @coordinates = blended.coordinates
+        @alpha = blended.alpha
+        self
+      end
+
+      def mix(other, amount = 0.5)
+        blend(other, amount)
+      end
+
+      def mix!(other, amount = 0.5)
+        blend!(other, amount)
+      end
+    end
+  end
+end