abachrome-float 0.1.6

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,171 @@
+{
+  "nodes": {
+    "devenv": {
+      "locked": {
+        "dir": "src/modules",
+        "lastModified": 1760162706,
+        "owner": "cachix",
+        "repo": "devenv",
+        "rev": "0d5ad578728fe4bce66eb4398b8b1e66deceb4e4",
+        "type": "github"
+      },
+      "original": {
+        "dir": "src/modules",
+        "owner": "cachix",
+        "repo": "devenv",
+        "type": "github"
+      }
+    },
+    "flake-compat": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1747046372,
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "9100a0f413b0c601e0533d1d94ffd501ce2e7885",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "flake-compat_2": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1747046372,
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "9100a0f413b0c601e0533d1d94ffd501ce2e7885",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "git-hooks": {
+      "inputs": {
+        "flake-compat": "flake-compat",
+        "gitignore": "gitignore",
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1759523803,
+        "owner": "cachix",
+        "repo": "git-hooks.nix",
+        "rev": "cfc9f7bb163ad8542029d303e599c0f7eee09835",
+        "type": "github"
+      },
+      "original": {
+        "owner": "cachix",
+        "repo": "git-hooks.nix",
+        "type": "github"
+      }
+    },
+    "gitignore": {
+      "inputs": {
+        "nixpkgs": [
+          "git-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": 1758532697,
+        "owner": "cachix",
+        "repo": "devenv-nixpkgs",
+        "rev": "207a4cb0e1253c7658c6736becc6eb9cace1f25f",
+        "type": "github"
+      },
+      "original": {
+        "owner": "cachix",
+        "ref": "rolling",
+        "repo": "devenv-nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-ruby": {
+      "inputs": {
+        "flake-compat": "flake-compat_2",
+        "flake-utils": "flake-utils",
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1759902829,
+        "owner": "bobvanderlinden",
+        "repo": "nixpkgs-ruby",
+        "rev": "5fba6c022a63f1e76dee4da71edddad8959f088a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "bobvanderlinden",
+        "repo": "nixpkgs-ruby",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "devenv": "devenv",
+        "git-hooks": "git-hooks",
+        "nixpkgs": "nixpkgs",
+        "nixpkgs-ruby": "nixpkgs-ruby",
+        "pre-commit-hooks": [
+          "git-hooks"
+        ]
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

data/devenv.nix

@@ -0,0 +1,52 @@
+{ pkgs, lib, config, inputs, ... }:
+
+{
+  # https://devenv.sh/basics/
+  env.GREET = "devenv";
+
+  # https://devenv.sh/packages/
+  packages = [ pkgs.git pkgs.ncurses];
+
+	languages.ruby.enable = true;
+	languages.ruby.version = "3.3.2";
+
+  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,8 @@
+inputs:
+  nixpkgs:
+    url: github:cachix/devenv-nixpkgs/rolling
+  nixpkgs-ruby:
+    url: github:bobvanderlinden/nixpkgs-ruby
+    inputs:
+      nixpkgs:
+        follows: nixpkgs

data/lib/abachrome/color.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+# Abachrome::Color - Core color representation class
+#
+# This is the central color class that represents colors across multiple color spaces
+# including sRGB, OKLAB, OKLCH, and linear RGB. The Color class encapsulates color
+# coordinates, alpha values, and color space information while providing methods
+# for color creation, conversion, and manipulation.
+#
+# Key features:
+# - Create colors from RGB, OKLAB, OKLCH values with factory methods
+# - Automatic coordinate validation against color space definitions
+# - Immutable color objects with equality and hash support
+# - Extensible through mixins for color space conversions and operations
+# - High-precision decimal arithmetic using AbcDecimal for accurate calculations
+# - Support for alpha (opacity) values with proper handling in conversions
+#
+# The class uses a mixin system to dynamically include functionality for converting
+# between color spaces, blending operations, and lightness adjustments. All coordinate
+# values are stored as AbcDecimal objects to maintain precision during color science
+# calculations and transformations.
+
+require "dry-inflector"
+require_relative "color_space"
+
+module Abachrome
+  class Color
+    attr_reader :color_space, :coordinates, :alpha
+
+    # Initializes a new Color object with the specified color space, coordinates, and alpha value.
+    #
+    # @param color_space [ColorSpace] The color space for this color instance
+    # @param coordinates [Array<Numeric, String>] The color coordinates in the specified color space
+    # @param alpha [Numeric, String] The alpha (opacity) value, between 0.0 and 1.0 (default: 1.0)
+    # @raise [ArgumentError] If the coordinates are invalid for the specified color space
+    # @return [Color] A new Color instance
+    def initialize(color_space, coordinates, alpha = "1.0".to_f)
+      @color_space = color_space
+      @coordinates = coordinates.map { |c| c.to_s.to_f }
+      @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
+
+    # Creates a new Color instance from RGB values
+    #
+    # @param r [Numeric] The red component value (typically 0-1)
+    # @param g [Numeric] The green component value (typically 0-1)
+    # @param b [Numeric] The blue component value (typically 0-1)
+    # @param a [Numeric] The alpha (opacity) component value (0-1), defaults to 1.0 (fully opaque)
+    # @return [Abachrome::Color] A new Color instance in the sRGB color space
+    def self.from_rgb(r, g, b, a = 1.0)
+      space = ColorSpace.find(:srgb)
+      new(space, [r, g, b], a)
+    end
+
+    # Creates a new Color instance from LRGB values
+    #
+    # @param r [Numeric] The red component value (typically 0-1)
+    # @param g [Numeric] The green component value (typically 0-1)
+    # @param b [Numeric] The blue component value (typically 0-1)
+    # @param a [Numeric] The alpha (opacity) component value (0-1), defaults to 1.0 (fully opaque)
+    # @return [Abachrome::Color] A new Color instance in the sRGB color space
+    def self.from_lrgb(r, g, b, a = 1.0)
+      space = ColorSpace.find(:lrgb)
+      new(space, [r, g, b], a)
+    end
+
+    # Creates a new Color object with OKLAB values.
+    #
+    # @param l [Float] The lightness component (L) of the OKLAB color space
+    # @param a [Float] The green-red component (a) of the OKLAB color space
+    # @param b [Float] The blue-yellow component (b) of the OKLAB color space
+    # @param alpha [Float] The alpha (opacity) value, from 0.0 to 1.0
+    # @return [Abachrome::Color] A new Color object in the OKLAB color space
+    def self.from_oklab(l, a, b, alpha = 1.0)
+      space = ColorSpace.find(:oklab)
+      new(space, [l, a, b], alpha)
+    end
+
+    # Creates a new color instance in the OKLCH color space.
+    #
+    # @param l [Numeric] The lightness component (L), typically in range 0..1
+    # @param c [Numeric] The chroma component (C), typically starting from 0 with no upper bound
+    # @param h [Numeric] The hue component (H) in degrees, typically in range 0..360
+    # @param alpha [Float] The alpha (opacity) component, in range 0..1, defaults to 1.0 (fully opaque)
+    # @return [Abachrome::Color] A new Color instance in the OKLCH color space
+    def self.from_oklch(l, c, h, alpha = 1.0)
+      space = ColorSpace.find(:oklch)
+      new(space, [l, c, h], alpha)
+    end
+
+    # Creates a new Color instance from YIQ values
+    #
+    # @param y [Numeric] The luma (brightness) component, typically in range 0 to 1
+    # @param i [Numeric] The in-phase component (orange-blue), typically in range -0.5957 to 0.5957
+    # @param q [Numeric] The quadrature component (purple-green), typically in range -0.5226 to 0.5226
+    # @param alpha [Numeric] The alpha (opacity) component value (0-1), defaults to 1.0 (fully opaque)
+    # @return [Abachrome::Color] A new Color instance in the YIQ color space
+    def self.from_yiq(y, i, q, alpha = 1.0)
+      space = ColorSpace.find(:yiq)
+      new(space, [y, i, q], alpha)
+    end
+
+    # Creates a new Color instance from CMYK values
+    #
+    # @param c [Numeric] The cyan component, typically in range 0 to 1
+    # @param m [Numeric] The magenta component, typically in range 0 to 1
+    # @param y [Numeric] The yellow component, typically in range 0 to 1
+    # @param k [Numeric] The key/black component, typically in range 0 to 1
+    # @param alpha [Numeric] The alpha (opacity) component value (0-1), defaults to 1.0 (fully opaque)
+    # @return [Abachrome::Color] A new Color instance in the CMYK color space
+    def self.from_cmyk(c, m, y, k, alpha = 1.0)
+      space = ColorSpace.find(:cmyk)
+      new(space, [c, m, y, k], alpha)
+    end
+
+    # Compares this color instance with another for equality.
+    #
+    # Two colors are considered equal if they have the same color space,
+    # coordinates, and alpha value.
+    #
+    # @param other [Object] The object to compare with
+    # @return [Boolean] true if the colors are equal, false otherwise
+    def ==(other)
+      return false unless other.is_a?(Color)
+
+      color_space == other.color_space &&
+        coordinates == other.coordinates &&
+        alpha == other.alpha
+    end
+
+    # Checks if this color is equal to another color object.
+    #
+    # @param other [Object] The object to compare with
+    # @return [Boolean] true if the two colors are equal, false otherwise
+    # @see ==
+    def eql?(other)
+      self == other
+    end
+
+    # Generates a hash code for this color instance
+    # based on its color space, coordinates, and alpha value.
+    # The method first converts these components to strings,
+    # then computes a hash of the resulting array.
+    #
+    # @return [Integer] a hash code that can be used for equality comparison
+    # and as a hash key in Hash objects
+    def hash
+      [color_space, coordinates, alpha].map(&:to_s).hash
+    end
+
+    # Returns a string representation of the color in the format "ColorSpaceName(coord1, coord2, coord3, alpha)"
+    #
+    # @return [String] A human-readable string representation of the color showing its
+    # color space name, coordinate values rounded to 3 decimal places, and alpha value
+    # (if not 1.0)
+    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
+
+    # Returns the color as a hexadecimal string representation.
+    #
+    # @return [String] A hex color string in the format "#RRGGBB" or "#RRGGBBAA" if alpha < 1.0
+    def to_hex
+      require_relative "outputs/css"
+      Outputs::CSS.format_hex(self)
+    end
+
+    private
+
+    # Validates that the number of coordinates matches the expected number for the color space.
+    # Compares the size of the coordinates array with the number of coordinates
+    # defined in the associated color space.
+    # @raise [ArgumentError] when the number of coordinates doesn't match the color space definition
+    # @return [nil] if validation passes
+    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
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/color_mixins/blend.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# Abachrome::ColorMixins::Blend - Color blending and mixing functionality
+#
+# This mixin provides methods for blending and mixing colors together in various color spaces.
+# The blend operation interpolates between two colors by a specified amount, creating smooth
+# color transitions. All blending operations preserve alpha values and can be performed in
+# the current color space or a specified target color space for optimal results.
+#
+# Key features:
+# - Linear interpolation between colors with configurable blend amounts
+# - Support for blending in different color spaces (sRGB, OKLAB, OKLCH)
+# - Both non-destructive (blend/mix) and destructive (blend!/mix!) variants
+# - Automatic color space conversion when blending colors from different spaces
+# - High-precision decimal arithmetic for accurate color calculations
+#
+# The mixin includes both immutable methods that return new color instances and mutable
+# methods that modify the current color object in place, providing flexibility for
+# different use cases and performance requirements.
+
+module Abachrome
+  module ColorMixins
+    module Blend
+      # @method blend
+      # Interpolates between two colors, creating a new color that is a blend of the two.
+      # The blend happens in the specified color space or the current color space if none is provided.
+      # #
+      # @param [Abachrome::Color] other The color to blend with
+      # @param [Float, Integer, #to_d] amount The blend amount between 0 and 1, where 0 returns the original color and 1 returns the other color. Defaults to 0.5 (midpoint)
+      # @param [Symbol, nil] target_color_space The color space to perform the blend in (optional)
+      # @return [Abachrome::Color] A new color representing the blend of the two colors
+      # @example Blend two colors equally
+      #   red.blend(blue, 0.5)
+      # @example Blend with 25% of another color
+      #   red.blend(blue, 0.25)
+      # @example Blend in a specific color space
+      #   red.blend(blue, 0.5, target_color_space: :oklab)
+      def blend(other, amount = 0.5, target_color_space: nil)
+        amount = amount.to_f
+
+        source = target_color_space ? to_color_space(target_color_space) : self
+        other = other.to_color_space(source.color_space)
+
+        l1, a1, b1 = coordinates.map { |_| _.to_f }
+        l2, a2, b2 = other.coordinates.map { |_| _.to_f }
+
+        blended_l = (1 - amount.to_f * l1)     + (amount.to_f * l2)
+        blended_a = (1 - amount.to_f * a1)     + (amount.to_f * a2)
+        blended_b = (1 - amount.to_f * b1)     + (amount.to_f * b2)
+
+        blended_alpha = alpha + ((other.alpha - alpha) * amount)
+
+        Color.new(
+          color_space,
+          [blended_l, blended_a, blended_b],
+          blended_alpha
+        )
+      end
+
+      # Blends this color with another color by the specified amount.
+      # This is a destructive version of the blend method, modifying the current
+      # color in place.
+      #
+      # @param other [Abachrome::Color] The color to blend with
+      # @param amount [Float] The blend amount, between 0.0 and 1.0, where 0.0 is
+      # this color and 1.0 is the other color (default: 0.5)
+      # @return [Abachrome::Color] Returns self after modification
+      def blend!(other, amount = 0.5)
+        blended = blend(other, amount)
+        @color_space = blended.color_space
+        @coordinates = blended.coordinates
+        @alpha = blended.alpha
+        self
+      end
+
+      # Alias for the blend method that mixes two colors together.
+      #
+      # @param other [Abachrome::Color] The color to mix with
+      # @param amount [Float] The amount to mix, between 0.0 and 1.0, where 0.0 returns the original color and 1.0 returns the other color (default: 0.5)
+      # @return [Abachrome::Color] A new color resulting from the mix of the two colors
+      def mix(other, amount = 0.5)
+        blend(other, amount)
+      end
+
+      # Mix the current color with another color.
+      #
+      # This method is an alias for blend!. It combines the current color with
+      # the provided color at the specified amount.
+      #
+      # @param other [Abachrome::Color] The color to mix with the current color
+      # @param amount [Numeric] The amount of the other color to mix in, from 0 to 1 (default: 0.5)
+      # @return [self] Returns the modified color object
+      def mix!(other, amount = 0.5)
+        blend!(other, amount)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.