abachrome 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 584251d0988a5611a22766c4665f4be880d636c70af0a612d7eb39994e32e1cc
-  data.tar.gz: 0c1b82ff4874f2c74d494cdc79b5b2b4c8259c7e387441477a3a6dcb2046faad
+  metadata.gz: adfda90185a392dcd8859acac1f53b7ac4d9ace7a083b1b643baeeea49de76b8
+  data.tar.gz: b7b66f5e35f5f7f16b1704fced9de7cb85b2088b98afaf6c9aa0f31ad8e4fdb2
 SHA512:
-  metadata.gz: 10cd1fd7eb789c3e3fb0d10a1753a139ef83c388d5d22b850397995872784cf8cc2a134d7f423eb8365e609919d2814c1decd16abf9ea7941e2718f587352a46
-  data.tar.gz: a0dac04fc6b12902df2650b50794f044467c8521f352123239f862ec547970601a623d04306ab4c124af96e64cd317a77cf1781302d31d54e54d9a005c4dcce9
+  metadata.gz: adaebc43ce61184e91852927c83f371234fdde03aeff491570b35146d0f899bb7919336c0f5908c23d80b8233c1a9327a7d8fe5a54da83eac1b32a3d04c7d26e
+  data.tar.gz: 4088bd45b14da9b2d7c475a07cd9ee5797df50abe03701f48f64f7c684edaac8b24736a53b0d49aac5fca88d4e45b21535c86fbfd927e7d2095d11b515e57ed8

data/lib/abachrome/abc_decimal.rb

@@ -320,6 +320,10 @@ module Abachrome
       @value.negative?
     end
 
+    def positive?
+      @value > 0
+    end
+
     # Calculates the arctangent of y/x using the signs of the arguments to determine the quadrant.
     # Unlike the standard Math.atan2, this method accepts AbcDecimal objects or any values
     # that can be converted to AbcDecimal.

data/lib/abachrome/color.rb

@@ -125,6 +125,30 @@ module Abachrome
       new(space, [c, m, y, k], alpha)
     end
 
+    # Creates a new Color instance from XYZ values
+    #
+    # @param x [Numeric] The X tristimulus value representing the CIE RGB red primary
+    # @param y [Numeric] The Y tristimulus value representing luminance
+    # @param z [Numeric] The Z tristimulus value representing the CIE RGB blue primary
+    # @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 XYZ color space
+    def self.from_xyz(x, y, z, alpha = 1.0)
+      space = ColorSpace.find(:xyz)
+      new(space, [x, y, z], alpha)
+    end
+
+    # Creates a new Color instance from LMS values
+    #
+    # @param l [Numeric] The long wavelength (L) cone response component
+    # @param m [Numeric] The medium wavelength (M) cone response component
+    # @param s [Numeric] The short wavelength (S) cone response component
+    # @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 LMS color space
+    def self.from_lms(l, m, s, alpha = 1.0)
+      space = ColorSpace.find(:lms)
+      new(space, [l, m, s], alpha)
+    end
+
     # Compares this color instance with another for equality.
     #
     # Two colors are considered equal if they have the same color space,

data/lib/abachrome/color_mixins/harmonies.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+# Abachrome::ColorMixins::Harmonies - Color Harmony Generation Module
+#
+# This module provides methods for generating color harmonies based on color theory.
+# Color harmonies are sets of colors that work well together according to established
+# design principles. The module uses OKLCH color space for hue manipulation, which
+# provides perceptually uniform results.
+#
+# Key features:
+# - Analogous harmony: Colors adjacent on the color wheel (±30°)
+# - Complementary harmony: Colors opposite on the color wheel (180°)
+# - Triadic harmony: Three colors evenly spaced around the color wheel (120° intervals)
+# - Tetradic/Square harmony: Four colors evenly spaced (90° intervals)
+# - Split-complementary harmony: Base color plus two colors adjacent to its complement (150°, 210°)
+# - Option to generate harmonies in different color spaces (HSL or OKLCH)
+#
+# All harmonies preserve the lightness and chroma of the base color while rotating
+# the hue to create harmonious color combinations.
+#
+# References:
+# - Color Theory: https://en.wikipedia.org/wiki/Color_theory
+# - Color Harmony: https://en.wikipedia.org/wiki/Harmony_(color)
+
+module Abachrome
+  module ColorMixins
+    module Harmonies
+      # Generates an analogous color harmony.
+      # Analogous colors are adjacent to each other on the color wheel,
+      # typically within ±30 degrees. This creates a harmonious, cohesive palette.
+      #
+      # @param angle [Numeric] The hue angle offset in degrees (default: 30)
+      # @param space [Symbol] The color space to use for hue manipulation (:hsl or :oklch, default: :oklch)
+      # @return [Array<Abachrome::Color>] An array of three colors: [color at -angle, original, color at +angle]
+      def analogous(angle: 30, space: :oklch)
+        original_space = color_space
+
+        # Convert to the specified space for hue manipulation
+        color_in_space = space == color_space.id ? self : to_color_space(space)
+        l, c, h = color_in_space.coordinates
+
+        # Generate analogous colors by rotating hue
+        color_minus = create_harmony_color(l, c, h - angle, space)
+        color_plus = create_harmony_color(l, c, h + angle, space)
+
+        # Convert back to original color space
+        [
+          color_minus.to_color_space(original_space.id),
+          self,
+          color_plus.to_color_space(original_space.id)
+        ]
+      end
+
+      # Generates a complementary color harmony.
+      # Complementary colors are opposite each other on the color wheel (180° apart).
+      # They create maximum contrast and vibrant combinations.
+      #
+      # @param space [Symbol] The color space to use for hue manipulation (:hsl or :oklch, default: :oklch)
+      # @return [Array<Abachrome::Color>] An array of two colors: [original, complement]
+      def complementary(space: :oklch)
+        original_space = color_space
+
+        # Convert to the specified space for hue manipulation
+        color_in_space = space == color_space.id ? self : to_color_space(space)
+        l, c, h = color_in_space.coordinates
+
+        # Generate complementary color by rotating hue 180°
+        complement = create_harmony_color(l, c, h + 180, space)
+
+        # Convert back to original color space
+        [
+          self,
+          complement.to_color_space(original_space.id)
+        ]
+      end
+
+      # Generates a triadic color harmony.
+      # Triadic colors are evenly spaced around the color wheel at 120° intervals.
+      # They create vibrant, balanced palettes with good contrast.
+      #
+      # @param space [Symbol] The color space to use for hue manipulation (:hsl or :oklch, default: :oklch)
+      # @return [Array<Abachrome::Color>] An array of three colors evenly spaced around the color wheel
+      def triadic(space: :oklch)
+        original_space = color_space
+
+        # Convert to the specified space for hue manipulation
+        color_in_space = space == color_space.id ? self : to_color_space(space)
+        l, c, h = color_in_space.coordinates
+
+        # Generate triadic colors by rotating hue 120° and 240°
+        color_1 = create_harmony_color(l, c, h + 120, space)
+        color_2 = create_harmony_color(l, c, h + 240, space)
+
+        # Convert back to original color space
+        [
+          self,
+          color_1.to_color_space(original_space.id),
+          color_2.to_color_space(original_space.id)
+        ]
+      end
+
+      # Generates a tetradic (square) color harmony.
+      # Tetradic colors are evenly spaced around the color wheel at 90° intervals.
+      # They create rich, varied palettes with multiple complementary pairs.
+      #
+      # @param space [Symbol] The color space to use for hue manipulation (:hsl or :oklch, default: :oklch)
+      # @return [Array<Abachrome::Color>] An array of four colors evenly spaced around the color wheel
+      def tetradic(space: :oklch)
+        original_space = color_space
+
+        # Convert to the specified space for hue manipulation
+        color_in_space = space == color_space.id ? self : to_color_space(space)
+        l, c, h = color_in_space.coordinates
+
+        # Generate tetradic colors by rotating hue 90°, 180°, and 270°
+        color_1 = create_harmony_color(l, c, h + 90, space)
+        color_2 = create_harmony_color(l, c, h + 180, space)
+        color_3 = create_harmony_color(l, c, h + 270, space)
+
+        # Convert back to original color space
+        [
+          self,
+          color_1.to_color_space(original_space.id),
+          color_2.to_color_space(original_space.id),
+          color_3.to_color_space(original_space.id)
+        ]
+      end
+
+      # Generates a split-complementary color harmony.
+      # Split-complementary uses the base color plus two colors adjacent to its complement
+      # (at 150° and 210° from the base). This creates strong visual contrast while being
+      # more subtle than a pure complementary scheme.
+      #
+      # @param space [Symbol] The color space to use for hue manipulation (:hsl or :oklch, default: :oklch)
+      # @return [Array<Abachrome::Color>] An array of three colors: [original, complement-30°, complement+30°]
+      def split_complementary(space: :oklch)
+        original_space = color_space
+
+        # Convert to the specified space for hue manipulation
+        color_in_space = space == color_space.id ? self : to_color_space(space)
+        l, c, h = color_in_space.coordinates
+
+        # Generate split-complementary colors at 150° and 210° (complement ± 30°)
+        color_1 = create_harmony_color(l, c, h + 150, space)
+        color_2 = create_harmony_color(l, c, h + 210, space)
+
+        # Convert back to original color space
+        [
+          self,
+          color_1.to_color_space(original_space.id),
+          color_2.to_color_space(original_space.id)
+        ]
+      end
+
+      private
+
+      # Helper method to create a harmony color with normalized hue
+      #
+      # @param l [AbcDecimal] The lightness value
+      # @param c [AbcDecimal] The chroma value
+      # @param h [Numeric] The hue angle in degrees (will be normalized to 0-360)
+      # @param space [Symbol] The color space (:hsl or :oklch)
+      # @return [Abachrome::Color] A new color in the specified color space
+      def create_harmony_color(l, c, h, space)
+        # Normalize hue to 0-360 range
+        normalized_hue = h % 360
+
+        case space
+        when :oklch
+          Abachrome::Color.from_oklch(l, c, normalized_hue, alpha)
+        when :hsl
+          # For HSL, assuming coordinates are [h, s, l]
+          # Note: HSL hue is first coordinate
+          Abachrome::Color.new(
+            Abachrome::ColorSpace.find(:hsl),
+            [normalized_hue, c, l],
+            alpha
+          )
+        else
+          raise ArgumentError, "Unsupported color space for harmonies: #{space}. Use :oklch or :hsl"
+        end
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/color_mixins/to_lms.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Abachrome::ColorMixins::ToLms - LMS color space conversion functionality
+#
+# This mixin provides methods for converting colors to the LMS color space, which represents
+# the response of the three types of cone cells in the human eye (Long, Medium, Short wavelength
+# sensitivity). LMS serves as an intermediate color space in the OKLAB transformation pipeline
+# and provides a foundation for perceptually uniform color representations.
+#
+# Key features:
+# - Convert colors to LMS with automatic converter lookup
+# - Both non-destructive (to_lms) and destructive (to_lms!) conversion methods
+# - Direct access to LMS components (long, medium, short)
+# - Utility methods for LMS array and value extraction
+# - Optimized to return the same object when no conversion is needed
+# - High-precision decimal arithmetic for accurate color science calculations
+#
+# The LMS color space uses three components: L (long wavelength), M (medium wavelength),
+# and S (short wavelength), representing cone cell responses that bridge the gap between
+# linear RGB and perceptually uniform color spaces like OKLAB.
+
+require_relative "../converter"
+
+module Abachrome
+  module ColorMixins
+    module ToLms
+      # Converts the current color to the LMS color space.
+      #
+      # If the color is already in LMS, it returns the color unchanged.
+      # Otherwise, it uses the Converter to transform the color to LMS.
+      #
+      # @return [Abachrome::Color] A new Color object in the LMS color space
+      def to_lms
+        return self if color_space.name == :lms
+
+        Converter.convert(self, :lms)
+      end
+
+      # Converts the color to the LMS color space in place.
+      # This method transforms the current color into LMS space,
+      # modifying the original object by updating its color space
+      # and coordinates if not already in LMS.
+      #
+      # @example
+      # color = Abachrome::Color.from_hex("#ff5500")
+      # color.to_lms!  # Color now uses LMS color space
+      #
+      # @return [Abachrome::Color] self, with updated color space and coordinates
+      def to_lms!
+        unless color_space.name == :lms
+          lms_color = to_lms
+          @color_space = lms_color.color_space
+          @coordinates = lms_color.coordinates
+        end
+        self
+      end
+
+      # Returns the L component (long wavelength) from the LMS color space.
+      #
+      # The L component represents the response of long-wavelength sensitive cone cells
+      # in the human eye, which are most sensitive to red light.
+      #
+      # @return [AbcDecimal] The L (long wavelength) value from the LMS color space
+      def long
+        to_lms.coordinates[0]
+      end
+
+      # Returns the M component (medium wavelength) from the LMS color space.
+      #
+      # The M component represents the response of medium-wavelength sensitive cone cells
+      # in the human eye, which are most sensitive to green light.
+      #
+      # @return [AbcDecimal] The M (medium wavelength) value from the LMS color space
+      def medium
+        to_lms.coordinates[1]
+      end
+
+      # Returns the S component (short wavelength) from the LMS color space.
+      #
+      # The S component represents the response of short-wavelength sensitive cone cells
+      # in the human eye, which are most sensitive to blue light.
+      #
+      # @return [AbcDecimal] The S (short wavelength) value from the LMS color space
+      def short
+        to_lms.coordinates[2]
+      end
+
+      # Returns the LMS color space coordinates for this color.
+      #
+      # @return [Array<AbcDecimal>] An array of LMS coordinates [L, M, S] representing the color in LMS color space
+      def lms_values
+        to_lms.coordinates
+      end
+
+      # Returns an array representation of the color's coordinates in the LMS color space.
+      #
+      # @return [Array<AbcDecimal>] An array containing the coordinates of the color
+      # in the LMS color space in the order [L, M, S]
+      def lms_array
+        to_lms.coordinates
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/color_mixins/to_xyz.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Abachrome::ColorMixins::ToXyz - XYZ color space conversion functionality
+#
+# This mixin provides methods for converting colors to the XYZ color space, which is the
+# CIE 1931 color space that forms the basis for most other color space definitions and
+# serves as a device-independent reference color space. XYZ represents colors using
+# tristimulus values that correspond to the response of the human visual system to light.
+#
+# Key features:
+# - Convert colors to XYZ with automatic converter lookup
+# - Both non-destructive (to_xyz) and destructive (to_xyz!) conversion methods
+# - Direct access to XYZ components (x, y, z)
+# - Utility methods for XYZ array and value extraction
+# - Optimized to return the same object when no conversion is needed
+# - High-precision decimal arithmetic for accurate color science calculations
+#
+# The XYZ color space uses three components: X, Y, and Z tristimulus values, providing
+# a device-independent representation of colors that serves as the foundation for defining
+# other color spaces, making it essential for accurate color transformations.
+
+require_relative "../converter"
+
+module Abachrome
+  module ColorMixins
+    module ToXyz
+      # Converts the current color to the XYZ color space.
+      #
+      # If the color is already in XYZ, it returns the color unchanged.
+      # Otherwise, it uses the Converter to transform the color to XYZ.
+      #
+      # @return [Abachrome::Color] A new Color object in the XYZ color space
+      def to_xyz
+        return self if color_space.name == :xyz
+
+        Converter.convert(self, :xyz)
+      end
+
+      # Converts the color to the XYZ color space in place.
+      # This method transforms the current color into XYZ space,
+      # modifying the original object by updating its color space
+      # and coordinates if not already in XYZ.
+      #
+      # @example
+      # color = Abachrome::Color.from_hex("#ff5500")
+      # color.to_xyz!  # Color now uses XYZ color space
+      #
+      # @return [Abachrome::Color] self, with updated color space and coordinates
+      def to_xyz!
+        unless color_space.name == :xyz
+          xyz_color = to_xyz
+          @color_space = xyz_color.color_space
+          @coordinates = xyz_color.coordinates
+        end
+        self
+      end
+
+      # Returns the X component from the XYZ color space.
+      #
+      # The X component represents the mix of cone response curves chosen to be
+      # nonnegative and represents a scale of the CIE RGB red primary.
+      #
+      # @return [AbcDecimal] The X tristimulus value from the XYZ color space
+      def x
+        to_xyz.coordinates[0]
+      end
+
+      # Returns the Y component from the XYZ color space.
+      #
+      # The Y component represents luminance, which closely matches human perception
+      # of brightness. It corresponds to the CIE RGB green primary.
+      #
+      # @return [AbcDecimal] The Y tristimulus value from the XYZ color space
+      def y
+        to_xyz.coordinates[1]
+      end
+
+      # Returns the Z component from the XYZ color space.
+      #
+      # The Z component represents the CIE RGB blue primary and is roughly equal
+      # to blue stimulation.
+      #
+      # @return [AbcDecimal] The Z tristimulus value from the XYZ color space
+      def z
+        to_xyz.coordinates[2]
+      end
+
+      # Returns the XYZ color space coordinates for this color.
+      #
+      # @return [Array<AbcDecimal>] An array of XYZ coordinates [X, Y, Z] representing the color in XYZ color space
+      def xyz_values
+        to_xyz.coordinates
+      end
+
+      # Returns an array representation of the color's coordinates in the XYZ color space.
+      #
+      # @return [Array<AbcDecimal>] An array containing the coordinates of the color
+      # in the XYZ color space in the order [X, Y, Z]
+      def xyz_array
+        to_xyz.coordinates
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/color_mixins/wcag.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# Abachrome::ColorMixins::Wcag - WCAG Accessibility Module
+#
+# This module provides methods for calculating color contrast ratios and checking
+# WCAG 2.0/2.1 compliance for accessibility. It implements the relative luminance
+# calculation with proper sRGB linearization according to WCAG specifications.
+#
+# Key features:
+# - Calculate relative luminance using WCAG formula: Y = 0.2126R + 0.7152G + 0.0722B
+# - Compute contrast ratio between two colors
+# - Check WCAG 2.0 Level AA and AAA compliance for normal and large text
+# - Check WCAG 2.1 non-text contrast compliance (3:1 minimum)
+# - Predicate methods for easy accessibility checks
+#
+# References:
+# - WCAG 2.0: https://www.w3.org/TR/WCAG20/
+# - WCAG 2.1: https://www.w3.org/TR/WCAG21/
+# - Relative luminance: https://www.w3.org/TR/WCAG20/#relativeluminancedef
+# - Contrast ratio: https://www.w3.org/TR/WCAG20/#contrast-ratiodef
+
+module Abachrome
+  module ColorMixins
+    module Wcag
+      # Calculates the relative luminance of the color according to WCAG specifications.
+      # Uses the formula: Y = 0.2126R + 0.7152G + 0.0722B
+      # where R, G, B are linearized sRGB values.
+      #
+      # The linearization follows the sRGB specification:
+      # - For values <= 0.03928: linear_value = value / 12.92
+      # - For values > 0.03928: linear_value = ((value + 0.055) / 1.055) ^ 2.4
+      #
+      # @return [AbcDecimal] The relative luminance value between 0.0 (darkest) and 1.0 (lightest)
+      def relative_luminance
+        rgb = to_srgb
+        r, g, b = rgb.coordinates
+
+        # Linearize sRGB values
+        r_linear = linearize_srgb_component(r)
+        g_linear = linearize_srgb_component(g)
+        b_linear = linearize_srgb_component(b)
+
+        # Apply WCAG luminance coefficients (Rec. 709)
+        AbcDecimal("0.2126") * r_linear +
+          AbcDecimal("0.7152") * g_linear +
+          AbcDecimal("0.0722") * b_linear
+      end
+
+      # Calculates the contrast ratio between this color and another color.
+      # The contrast ratio is calculated according to WCAG:
+      # (L1 + 0.05) / (L2 + 0.05)
+      # where L1 is the relative luminance of the lighter color and
+      # L2 is the relative luminance of the darker color.
+      #
+      # @param other [Abachrome::Color] The color to compare against
+      # @return [AbcDecimal] The contrast ratio, ranging from 1:1 (no contrast) to 21:1 (maximum contrast)
+      def contrast_ratio(other)
+        l1 = relative_luminance
+        l2 = other.relative_luminance
+
+        # Ensure L1 is the lighter color
+        l1, l2 = l2, l1 if l1 < l2
+
+        (l1 + AbcDecimal("0.05")) / (l2 + AbcDecimal("0.05"))
+      end
+
+      # Checks if the contrast ratio with another color meets WCAG 2.0 Level AA standards.
+      # AA requirements:
+      # - Normal text (< 18pt or < 14pt bold): minimum 4.5:1 contrast ratio
+      # - Large text (≥ 18pt or ≥ 14pt bold): minimum 3:1 contrast ratio
+      #
+      # @param other [Abachrome::Color] The color to compare against
+      # @param large_text [Boolean] Whether the text is considered large (default: false)
+      # @return [Boolean] true if the contrast meets AA standards
+      def meets_wcag_aa?(other, large_text: false)
+        ratio = contrast_ratio(other)
+        minimum = large_text ? AbcDecimal("3.0") : AbcDecimal("4.5")
+        ratio >= minimum
+      end
+
+      # Checks if the contrast ratio with another color meets WCAG 2.0 Level AAA standards.
+      # AAA requirements:
+      # - Normal text (< 18pt or < 14pt bold): minimum 7:1 contrast ratio
+      # - Large text (≥ 18pt or ≥ 14pt bold): minimum 4.5:1 contrast ratio
+      #
+      # @param other [Abachrome::Color] The color to compare against
+      # @param large_text [Boolean] Whether the text is considered large (default: false)
+      # @return [Boolean] true if the contrast meets AAA standards
+      def meets_wcag_aaa?(other, large_text: false)
+        ratio = contrast_ratio(other)
+        minimum = large_text ? AbcDecimal("4.5") : AbcDecimal("7.0")
+        ratio >= minimum
+      end
+
+      # Checks if the contrast ratio with another color meets WCAG 2.1 non-text contrast requirements.
+      # Non-text contrast applies to:
+      # - Graphical objects (icons, graphs, infographics)
+      # - User interface components (buttons, form inputs, focus indicators)
+      # Requirement: minimum 3:1 contrast ratio
+      #
+      # @param other [Abachrome::Color] The color to compare against
+      # @return [Boolean] true if the contrast meets the 3:1 minimum for non-text content
+      def meets_wcag_non_text?(other)
+        ratio = contrast_ratio(other)
+        ratio >= AbcDecimal("3.0")
+      end
+
+      private
+
+      # Linearizes a single sRGB component value according to the sRGB specification.
+      # This is required before applying the luminance coefficients.
+      #
+      # @param component [AbcDecimal] The sRGB component value (0.0 to 1.0)
+      # @return [AbcDecimal] The linearized component value
+      def linearize_srgb_component(component)
+        if component <= AbcDecimal("0.03928")
+          component / AbcDecimal("12.92")
+        else
+          ((component + AbcDecimal("0.055")) / AbcDecimal("1.055"))**AbcDecimal("2.4")
+        end
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/color_models/cmyk.rb

@@ -38,7 +38,8 @@ module Abachrome
             case value
             when String
               if value.end_with?("%")
-                AbcDecimal(value.chomp("%")) / AbcDecimal(100)
+                value_without_percent = value.chomp("%")
+                AbcDecimal(value_without_percent) / AbcDecimal(100)
               else
                 AbcDecimal(value)
               end

data/lib/abachrome/color_models/xyz.rb

@@ -28,4 +28,12 @@ module Abachrome
   end
 end
 
+ColorSpace.register(
+  :xyz,
+  "XYZ",
+  %w[x y z],
+  nil,
+  []
+)
+
 # Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/lms_to_oklab.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module Converters
+    class LmsToOklab < Abachrome::Converters::Base
+      # Converts a color from LMS color space to OKLAB color space.
+      #
+      # This method converts LMS to LRGB first, then to OKLAB. The LMS color space
+      # represents the response of the three types of cone cells in the human eye.
+      #
+      # @param lms_color [Abachrome::Color] The color in LMS color space
+      # @raise [ArgumentError] If the input color is not in LMS color space
+      # @return [Abachrome::Color] The resulting color in OKLAB color space with
+      # the same alpha as the input color
+      def self.convert(lms_color)
+        raise_unless lms_color, :lms
+
+        # Convert LMS to LRGB first
+        lrgb_color = Converters::LmsToLrgb.convert(lms_color)
+
+        # Then convert LRGB to OKLAB
+        Converters::LrgbToOklab.convert(lrgb_color)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/lrgb_to_lms.rb

@@ -1,3 +1,29 @@
 # frozen_string_literal: true
 
+module Abachrome
+  module Converters
+    class LrgbToLms < Abachrome::Converters::Base
+      # Converts a color from linear RGB color space to LMS color space.
+      #
+      # This method converts linear RGB to XYZ first, then to LMS cone response space.
+      # The LMS color space represents the response of the three types of cone cells
+      # in the human eye (Long, Medium, Short wavelength sensitivity).
+      #
+      # @param lrgb_color [Abachrome::Color] The color in linear RGB color space
+      # @raise [ArgumentError] If the input color is not in linear RGB color space
+      # @return [Abachrome::Color] The resulting color in LMS color space with
+      # the same alpha as the input color
+      def self.convert(lrgb_color)
+        raise_unless lrgb_color, :lrgb
+
+        # Convert linear RGB to XYZ first
+        xyz_color = Converters::LrgbToXyz.convert(lrgb_color)
+
+        # Then convert XYZ to LMS
+        Converters::XyzToLms.convert(xyz_color)
+      end
+    end
+  end
+end
+
 # Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/oklab_to_xyz.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module Converters
+    class OklabToXyz < Abachrome::Converters::Base
+      # Converts a color from OKLAB color space to XYZ color space.
+      #
+      # This method converts OKLAB to LMS first, then to XYZ. The OKLAB color space
+      # is a perceptually uniform color space, and XYZ is the CIE 1931 color space
+      # that forms the basis for most other color space definitions.
+      #
+      # @param oklab_color [Abachrome::Color] The color in OKLAB color space
+      # @raise [ArgumentError] If the input color is not in OKLAB color space
+      # @return [Abachrome::Color] The resulting color in XYZ color space with
+      # the same alpha as the input color
+      def self.convert(oklab_color)
+        raise_unless oklab_color, :oklab
+
+        # Convert OKLAB to LMS first
+        lms_color = Converters::OklabToLms.convert(oklab_color)
+
+        # Then convert LMS to XYZ
+        Converters::LmsToXyz.convert(lms_color)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/oklch_to_lms.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module Converters
+    class OklchToLms < Abachrome::Converters::Base
+      # Converts a color from OKLCH color space to LMS color space.
+      #
+      # This method converts OKLCH to OKLAB first, then to LMS. The OKLCH color space
+      # is a cylindrical representation of OKLAB using lightness, chroma, and hue.
+      #
+      # @param oklch_color [Abachrome::Color] The color in OKLCH color space
+      # @raise [ArgumentError] If the input color is not in OKLCH color space
+      # @return [Abachrome::Color] The resulting color in LMS color space with
+      # the same alpha as the input color
+      def self.convert(oklch_color)
+        raise_unless oklch_color, :oklch
+
+        # Convert OKLCH to OKLAB first
+        oklab_color = Converters::OklchToOklab.convert(oklch_color)
+
+        # Then convert OKLAB to LMS
+        Converters::OklabToLms.convert(oklab_color)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/srgb_to_lms.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module Converters
+    class SrgbToLms < Abachrome::Converters::Base
+      # Converts a color from sRGB color space to LMS color space.
+      #
+      # This method converts sRGB to linear RGB first, then to LMS cone response space.
+      # The LMS color space represents the response of the three types of cone cells
+      # in the human eye (Long, Medium, Short wavelength sensitivity).
+      #
+      # @param srgb_color [Abachrome::Color] The color in sRGB color space
+      # @raise [ArgumentError] If the input color is not in sRGB color space
+      # @return [Abachrome::Color] The resulting color in LMS color space with
+      # the same alpha as the input color
+      def self.convert(srgb_color)
+        raise_unless srgb_color, :srgb
+
+        # Convert sRGB to linear RGB first
+        lrgb_color = Converters::SrgbToLrgb.convert(srgb_color)
+
+        # Then convert linear RGB to LMS
+        Converters::LrgbToLms.convert(lrgb_color)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/srgb_to_xyz.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module Converters
+    class SrgbToXyz < Abachrome::Converters::Base
+      # Converts a color from sRGB color space to XYZ color space.
+      #
+      # This method first converts sRGB to linear RGB by removing gamma correction,
+      # then applies the linear RGB to XYZ transformation matrix. The XYZ color space
+      # is the CIE 1931 color space that forms the basis for most other color space
+      # definitions and serves as a device-independent reference.
+      #
+      # @param srgb_color [Abachrome::Color] The color in sRGB color space
+      # @raise [ArgumentError] If the input color is not in sRGB color space
+      # @return [Abachrome::Color] The resulting color in XYZ color space with
+      # the same alpha as the input color
+      def self.convert(srgb_color)
+        raise_unless srgb_color, :srgb
+
+        # Convert sRGB to linear RGB first
+        lrgb_color = Converters::SrgbToLrgb.convert(srgb_color)
+
+        # Then convert linear RGB to XYZ
+        Converters::LrgbToXyz.convert(lrgb_color)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/xyz_to_lrgb.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module Converters
+    class XyzToLrgb < Abachrome::Converters::Base
+      # Converts a color from XYZ color space to linear RGB color space.
+      #
+      # This method implements the XYZ to linear RGB transformation using the inverse
+      # of the standard transformation matrix for the sRGB color space with D65 white point.
+      # The XYZ color space is the CIE 1931 color space that serves as a device-independent
+      # reference for color definitions.
+      #
+      # @param xyz_color [Abachrome::Color] The color in XYZ color space
+      # @raise [ArgumentError] If the input color is not in XYZ color space
+      # @return [Abachrome::Color] The resulting color in linear RGB color space with
+      # the same alpha as the input color
+      def self.convert(xyz_color)
+        raise_unless xyz_color, :xyz
+
+        x, y, z = xyz_color.coordinates.map { |_| AbcDecimal(_) }
+
+        # XYZ to Linear RGB transformation matrix (inverse of sRGB/D65)
+        r = (x * AD("3.2404542")) + (y * AD("-1.5371385")) + (z * AD("-0.4985314"))
+        g = (x * AD("-0.9692660")) + (y * AD("1.8760108")) + (z * AD("0.0415560"))
+        b = (x * AD("0.0556434")) + (y * AD("-0.2040259")) + (z * AD("1.0572252"))
+
+        Color.new(ColorSpace.find(:lrgb), [r, g, b], xyz_color.alpha)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/xyz_to_srgb.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module Converters
+    class XyzToSrgb < Abachrome::Converters::Base
+      # Converts a color from XYZ color space to sRGB color space.
+      #
+      # This method first converts XYZ to linear RGB using the inverse transformation
+      # matrix, then applies gamma correction to convert to sRGB. The XYZ color space
+      # is the CIE 1931 color space that forms the basis for most other color space
+      # definitions and serves as a device-independent reference.
+      #
+      # @param xyz_color [Abachrome::Color] The color in XYZ color space
+      # @raise [ArgumentError] If the input color is not in XYZ color space
+      # @return [Abachrome::Color] The resulting color in sRGB color space with
+      # the same alpha as the input color
+      def self.convert(xyz_color)
+        raise_unless xyz_color, :xyz
+
+        # Convert XYZ to linear RGB first
+        lrgb_color = Converters::XyzToLrgb.convert(xyz_color)
+
+        # Then convert linear RGB to sRGB
+        Converters::LrgbToSrgb.convert(lrgb_color)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/floatify.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+# Abachrome::Floatify - Float-based arithmetic for color calculations
+#
+# This module monkey-patches AbcDecimal to use Float instead of BigDecimal.
+# Require this file to make AbcDecimal use floats throughout the codebase.
+#
+# Usage:
+#   require 'abachrome/floatify'
+#
+# This makes AbcDecimal a drop-in replacement that uses Float arithmetic
+# for performance-critical applications where BigDecimal precision is not required.
+
+require_relative "abc_decimal"
+
+module Abachrome
+  class AbcDecimal
+    # Remove the precision-related constant and attribute
+    remove_const(:DEFAULT_PRECISION) if defined?(DEFAULT_PRECISION)
+
+    attr_accessor :value
+
+    # Initializes a new AbcDecimal object with the specified value.
+    # Precision parameter is ignored when floatify is loaded.
+    #
+    # @param value [AbcDecimal, Rational, #to_f] The numeric value to represent.
+    # If an AbcDecimal is provided, its internal value is used.
+    # Otherwise, the value is converted to a float.
+    # @param _precision [Integer] Ignored - included for API compatibility
+    # @return [AbcDecimal] A new AbcDecimal instance.
+    def initialize(value, _precision = nil)
+      @value = case value
+               when AbcDecimal
+                 value.value
+               else
+                 value.to_f
+               end
+    end
+
+    # Returns a string representation of the float value.
+    #
+    # @return [String] The float value as a string
+    def to_s
+      @value.to_s
+    end
+
+    # Converts the value to a floating-point number.
+    #
+    # @return [Float] the floating-point representation of the AbcDecimal value
+    def to_f
+      @value
+    end
+
+    # Creates a new AbcDecimal from a string representation of a number.
+    #
+    # @param str [String] The string representation of a number to convert to an AbcDecimal
+    # @param _precision [Integer] Ignored - included for API compatibility
+    # @return [AbcDecimal] A new AbcDecimal instance initialized with the given string value
+    def self.from_string(str, _precision = nil)
+      new(str)
+    end
+
+    # Creates a new AbcDecimal from a Rational number.
+    #
+    # @param rational [Rational] The rational number to convert to an AbcDecimal
+    # @param _precision [Integer] Ignored - included for API compatibility
+    # @return [AbcDecimal] A new AbcDecimal instance with the value of the given rational number
+    def self.from_rational(rational, _precision = nil)
+      new(rational)
+    end
+
+    # Creates a new AbcDecimal instance from a float value.
+    #
+    # @param float [Float] The floating point number to convert to an AbcDecimal
+    # @param _precision [Integer] Ignored - included for API compatibility
+    # @return [AbcDecimal] A new AbcDecimal instance representing the given float value
+    def self.from_float(float, _precision = nil)
+      new(float)
+    end
+
+    # Creates a new AbcDecimal from an integer value.
+    #
+    # @param integer [Integer] The integer value to convert to an AbcDecimal
+    # @param _precision [Integer] Ignored - included for API compatibility
+    # @return [AbcDecimal] A new AbcDecimal instance with the specified integer value
+    def self.from_integer(integer, _precision = nil)
+      new(integer)
+    end
+
+    # Addition operation
+    #
+    # Adds another value to this float.
+    #
+    # @param other [AbcDecimal, Numeric] The value to add. If not an AbcDecimal,
+    #   it will be converted to one.
+    # @return [AbcDecimal] A new AbcDecimal instance with the sum of the two values
+    def +(other)
+      other_value = other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value
+      self.class.new(@value + other_value)
+    end
+
+    # Subtracts another numeric value from this AbcDecimal.
+    #
+    # @param other [AbcDecimal, Numeric] The value to subtract from this AbcDecimal.
+    # @return [AbcDecimal] A new AbcDecimal representing the result of the subtraction.
+    def -(other)
+      other_value = other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value
+      self.class.new(@value - other_value)
+    end
+
+    # Multiplies this AbcDecimal by another value.
+    #
+    # @param other [Object] The value to multiply by. If not an AbcDecimal, it will be converted to one.
+    # @return [AbcDecimal] A new AbcDecimal instance representing the product of this float and the other value.
+    def *(other)
+      other_value = other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value
+      self.class.new(@value * other_value)
+    end
+
+    # Divides this float by another value.
+    #
+    # @param other [Numeric, AbcDecimal] The divisor, which can be an AbcDecimal instance or any numeric value
+    # @return [AbcDecimal] A new AbcDecimal representing the result of the division
+    def /(other)
+      other_value = other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value
+      self.class.new(@value / other_value)
+    end
+
+    # Performs modulo operation with another value.
+    #
+    # @param other [Numeric, AbcDecimal] The divisor for the modulo operation
+    # @return [AbcDecimal] A new AbcDecimal containing the remainder after division
+    def %(other)
+      other_value = other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value
+      self.class.new(@value % other_value)
+    end
+
+    # Constrains the value to be between the specified minimum and maximum values.
+    #
+    # @param min [Numeric, AbcDecimal] The minimum value to clamp to
+    # @param max [Numeric, AbcDecimal] The maximum value to clamp to
+    # @return [Float] A float within the specified range
+    def clamp(min, max)
+      @value.clamp(AbcDecimal(min).value, AbcDecimal(max).value)
+    end
+
+    # Raises self to the power of another value.
+    #
+    # @param other [Numeric, AbcDecimal] The exponent to raise this value to
+    # @return [AbcDecimal] A new AbcDecimal representing self raised to the power of other
+    def **(other)
+      other_value = other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value
+      self.class.new(@value**other_value)
+    end
+
+    # Allows for mixed arithmetic operations between AbcDecimal and other numeric types.
+    #
+    # @param other [Numeric] The other number to be coerced into an AbcDecimal object
+    # @return [Array<AbcDecimal>] A two-element array containing the coerced value and self,
+    # allowing Ruby to perform arithmetic operations with mixed types
+    def coerce(other)
+      [self.class.new(other), self]
+    end
+
+    # Returns a string representation of the float value for inspection purposes.
+    #
+    # @return [String] A string in the format "ClassName('value')"
+    def inspect
+      "#{self.class}('#{self}')"
+    end
+
+    # Compares this float value with another value for equality.
+    # Attempts to convert the other value to an AbcDecimal if it isn't one already.
+    #
+    # @param other [Object] The value to compare against this AbcDecimal
+    # @return [Boolean] True if the values are equal, false otherwise
+    def ==(other)
+      @value == (other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value)
+    end
+
+    # Compares this AbcDecimal instance with another AbcDecimal or a value that can be
+    # converted to an AbcDecimal.
+    #
+    # @param other [Object] The value to compare with this AbcDecimal.
+    # If not an AbcDecimal, it will be converted using AbcDecimal().
+    # @return [Integer, nil] Returns -1 if self is less than other,
+    # 0 if they are equal,
+    # 1 if self is greater than other,
+    # or nil if the comparison is not possible.
+    def <=>(other)
+      @value <=> (other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value)
+    end
+
+    # Compares this float with another value.
+    #
+    # @param other [Object] The value to compare with. Can be an AbcDecimal or any value
+    # convertible to AbcDecimal
+    # @return [Boolean] true if this float is greater than the other value, false otherwise
+    def >(other)
+      @value > (other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value)
+    end
+
+    # Compares this float value with another value.
+    #
+    # @param other [Object] The value to compare against. If not an AbcDecimal,
+    # it will be converted to one.
+    # @return [Boolean] true if this float is greater than or equal to the other value,
+    # false otherwise.
+    def >=(other)
+      @value >= (other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value)
+    end
+
+    # Compares this float with another value.
+    #
+    # @param other [Object] The value to compare with. Will be coerced to AbcDecimal if not already an instance.
+    # @return [Boolean] true if this float is less than the other value, false otherwise.
+    def <(other)
+      @value < (other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value)
+    end
+
+    # Compares this AbcDecimal with another value.
+    #
+    # @param other [AbcDecimal, Numeric] The value to compare with. If not an AbcDecimal,
+    # it will be converted to one.
+    # @return [Boolean] true if this AbcDecimal is less than or equal to the other value,
+    # false otherwise.
+    def <=(other)
+      @value <= (other.is_a?(AbcDecimal) ? other.value : AbcDecimal(other).value)
+    end
+
+    # Rounds this float to a specified precision.
+    #
+    # @param args [Array] Arguments to be passed to Float#round. Can include
+    # the number of decimal places to round to.
+    # @return [AbcDecimal] A new AbcDecimal instance with the rounded value
+    def round(*args)
+      AbcDecimal(@value.round(*args))
+    end
+
+    # Returns the absolute value (magnitude) of the float number.
+    #
+    # @param _args [Array] Ignored - included for API compatibility
+    # @return [AbcDecimal] The absolute value of the float number
+    def abs(*_args)
+      AbcDecimal(@value.abs)
+    end
+
+    # Returns the square root of the AbcDecimal value.
+    #
+    # @return [AbcDecimal] A new AbcDecimal representing the square root of the value
+    def sqrt
+      AbcDecimal(Math.sqrt(@value))
+    end
+
+    # Returns true if the internal value is negative, false otherwise.
+    #
+    # @return [Boolean] true if the value is negative, false otherwise
+    def negative?
+      @value.negative?
+    end
+
+    # Returns true if the internal value is positive, false otherwise.
+    #
+    # @return [Boolean] true if the value is positive, false otherwise
+    def positive?
+      @value > 0
+    end
+
+    # Calculates the arctangent of y/x using the signs of the arguments to determine the quadrant.
+    #
+    # @param y [AbcDecimal, Numeric] The y coordinate
+    # @param x [AbcDecimal, Numeric] The x coordinate
+    # @return [AbcDecimal] The angle in radians between the positive x-axis and the ray to the point (x,y)
+    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
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Abachrome
-  VERSION = "0.1.6"
+  VERSION = "0.2.0"
 end
 
 # Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: abachrome
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - Durable Programming
@@ -66,14 +66,18 @@ files:
 - lib/abachrome/abc_decimal.rb
 - lib/abachrome/color.rb
 - lib/abachrome/color_mixins/blend.rb
+- lib/abachrome/color_mixins/harmonies.rb
 - lib/abachrome/color_mixins/lighten.rb
 - lib/abachrome/color_mixins/spectral_mix.rb
 - lib/abachrome/color_mixins/to_colorspace.rb
 - lib/abachrome/color_mixins/to_grayscale.rb
+- lib/abachrome/color_mixins/to_lms.rb
 - lib/abachrome/color_mixins/to_lrgb.rb
 - lib/abachrome/color_mixins/to_oklab.rb
 - lib/abachrome/color_mixins/to_oklch.rb
 - lib/abachrome/color_mixins/to_srgb.rb
+- lib/abachrome/color_mixins/to_xyz.rb
+- lib/abachrome/color_mixins/wcag.rb
 - lib/abachrome/color_models/cmyk.rb
 - lib/abachrome/color_models/hsv.rb
 - lib/abachrome/color_models/lms.rb
@@ -87,6 +91,7 @@ files:
 - lib/abachrome/converters/base.rb
 - lib/abachrome/converters/cmyk_to_srgb.rb
 - lib/abachrome/converters/lms_to_lrgb.rb
+- lib/abachrome/converters/lms_to_oklab.rb
 - lib/abachrome/converters/lms_to_srgb.rb
 - lib/abachrome/converters/lms_to_xyz.rb
 - lib/abachrome/converters/lrgb_to_lms.rb
@@ -97,18 +102,25 @@ files:
 - lib/abachrome/converters/oklab_to_lrgb.rb
 - lib/abachrome/converters/oklab_to_oklch.rb
 - lib/abachrome/converters/oklab_to_srgb.rb
+- lib/abachrome/converters/oklab_to_xyz.rb
+- lib/abachrome/converters/oklch_to_lms.rb
 - lib/abachrome/converters/oklch_to_lrgb.rb
 - lib/abachrome/converters/oklch_to_oklab.rb
 - lib/abachrome/converters/oklch_to_srgb.rb
 - lib/abachrome/converters/oklch_to_xyz.rb
 - lib/abachrome/converters/srgb_to_cmyk.rb
+- lib/abachrome/converters/srgb_to_lms.rb
 - lib/abachrome/converters/srgb_to_lrgb.rb
 - lib/abachrome/converters/srgb_to_oklab.rb
 - lib/abachrome/converters/srgb_to_oklch.rb
+- lib/abachrome/converters/srgb_to_xyz.rb
 - lib/abachrome/converters/srgb_to_yiq.rb
 - lib/abachrome/converters/xyz_to_lms.rb
+- lib/abachrome/converters/xyz_to_lrgb.rb
 - lib/abachrome/converters/xyz_to_oklab.rb
+- lib/abachrome/converters/xyz_to_srgb.rb
 - lib/abachrome/converters/yiq_to_srgb.rb
+- lib/abachrome/floatify.rb
 - lib/abachrome/gamut/base.rb
 - lib/abachrome/gamut/p3.rb
 - lib/abachrome/gamut/rec2020.rb