abachrome 0.1.5 → 0.2.0

data/lib/abachrome/color_mixins/to_srgb.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Abachrome::ColorMixins::ToSrgb - sRGB color space conversion functionality
 #
 # This mixin provides methods for converting colors to the sRGB color space, which is the
@@ -23,11 +25,11 @@ module Abachrome
   module ColorMixins
     module ToSrgb
       # Converts the current color to the sRGB color space.
-      # 
+      #
       # If the color is already in the sRGB color space, returns the color instance
       # unchanged. Otherwise, performs a color space conversion from the current
       # color space to sRGB.
-      # 
+      #
       # @return [Abachrome::Color] A new Color instance in the sRGB color space,
       # or self if already in sRGB
       def to_srgb
@@ -37,7 +39,7 @@ module Abachrome
       end
 
       # Alias for #to_srgb method.
-      # 
+      #
       # @return [Abachrome::Color] The color converted to sRGB color space
       def to_rgb
         # assume they mean srgb
@@ -59,7 +61,7 @@ module Abachrome
       # Converts the current color to sRGB color space in place.
       # This is an alias for {#to_srgb!} as RGB commonly refers to sRGB
       # in web and design contexts.
-      # 
+      #
       # @return [self] Returns self after converting to sRGB
       def to_rgb!
         # assume they mean srgb
@@ -67,7 +69,7 @@ module Abachrome
       end
 
       # Returns the red component of the color in the sRGB color space.
-      # 
+      #
       # @return [AbcDecimal] The red component value in the sRGB color space,
       # normalized between 0 and 1.
       def red
@@ -75,27 +77,27 @@ module Abachrome
       end
 
       # Returns the green component of the color in sRGB space.
-      # 
+      #
       # This method converts the current color to sRGB color space if needed,
       # then extracts the green component (second coordinate).
-      # 
+      #
       # @return [AbcDecimal] The green component value in the sRGB color space, typically in the range 0-1
       def green
         to_srgb.coordinates[1]
       end
 
       # Returns the blue component of the color in sRGB color space.
-      # 
+      #
       # This method converts the current color to sRGB if needed and
       # extracts the third coordinate value (blue).
-      # 
+      #
       # @return [AbcDecimal] The blue component value in sRGB space, typically in range 0-1
       def blue
         to_srgb.coordinates[2]
       end
 
       # Returns the RGB color values in the sRGB color space.
-      # 
+      #
       # @return [Array<AbcDecimal>] An array of three AbcDecimal values representing
       # the red, green, and blue color components in the sRGB color space.
       def srgb_values
@@ -103,18 +105,18 @@ module Abachrome
       end
 
       # Returns the RGB values of the color as coordinates in the sRGB color space.
-      # 
+      #
       # @return [Array<Abachrome::AbcDecimal>] The RGB coordinates (red, green, blue) in sRGB color space
       def rgb_values
         to_srgb.coordinates
       end
 
       # Returns an array of RGB values (0-255) for this color.
-      # 
+      #
       # This method converts the color to sRGB, then scales the component values
       # from the 0-1 range to the 0-255 range commonly used in RGB color codes.
       # Values are rounded to the nearest integer and clamped between 0 and 255.
-      # 
+      #
       # @return [Array<Integer>] An array of three integers representing the [R, G, B]
       # values in the 0-255 range
       def rgb_array
@@ -123,7 +125,7 @@ module Abachrome
 
       # Returns a hexadecimal representation of this color in sRGB color space.
       # Converts the color to sRGB, then formats it as a hexadecimal string.
-      # 
+      #
       # @return [String] A string in the format "#RRGGBB" where RR, GG, and BB are
       # the hexadecimal representations of the red, green, and blue components,
       # each ranging from 00 to FF.
@@ -137,4 +139,4 @@ module Abachrome
   end
 end
 
-# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.
+# 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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+# Abachrome::ColorModels::CMYK - CMYK color space model utilities
+#
+# This module provides utility methods for the CMYK (Cyan, Magenta, Yellow, Key/Black)
+# color model within the Abachrome color manipulation library. CMYK represents colors
+# using the subtractive color synthesis model used in printing and physical media.
+#
+# Key features:
+# - Subtractive color model (ink on paper, not light)
+# - Four channels: Cyan, Magenta, Yellow, and Key (Black)
+# - Supports Undercolor Removal (UCR) for ink savings
+# - Supports Gray Component Replacement (GCR) for richer blacks
+# - High-precision BigDecimal arithmetic for exact ink percentages
+# - Essential for print media, PDF generation, and pre-press workflows
+#
+# The CMYK model is fundamental for professional printing, where the fourth channel
+# (Black/Key) is added to achieve crisp text and deep shadows that cannot be produced
+# by combining cyan, magenta, and yellow inks alone.
+
+require_relative "../abc_decimal"
+
+module Abachrome
+  module ColorModels
+    class CMYK
+      include Abachrome::ToAbcd
+
+      class << self
+        # Normalizes CMYK color component values to the [0,1] range.
+        #
+        # @param c [Numeric] Cyan component (0-1 or 0-100 for percentages)
+        # @param m [Numeric] Magenta component (0-1 or 0-100 for percentages)
+        # @param y [Numeric] Yellow component (0-1 or 0-100 for percentages)
+        # @param k [Numeric] Key/Black component (0-1 or 0-100 for percentages)
+        # @return [Array<AbcDecimal>] Array of four normalized components as AbcDecimal objects
+        def normalize(c, m, y, k)
+          [c, m, y, k].map do |value|
+            case value
+            when String
+              if value.end_with?("%")
+                value_without_percent = value.chomp("%")
+                AbcDecimal(value_without_percent) / AbcDecimal(100)
+              else
+                AbcDecimal(value)
+              end
+            when Numeric
+              if value > 1
+                AbcDecimal(value) / AbcDecimal(100)
+              else
+                AbcDecimal(value)
+              end
+            end
+          end
+        end
+
+        # Converts RGB values to CMYK using the standard naive conversion.
+        # This produces high ink coverage and is generally not recommended for production.
+        #
+        # @param r [Numeric] Red component (0-1)
+        # @param g [Numeric] Green component (0-1)
+        # @param b [Numeric] Blue component (0-1)
+        # @return [Array<AbcDecimal>] Array of [c, m, y, k] values
+        def from_rgb_naive(r, g, b)
+          r = AbcDecimal(r)
+          g = AbcDecimal(g)
+          b = AbcDecimal(b)
+
+          # Simple complementary conversion
+          c = AbcDecimal(1) - r
+          m = AbcDecimal(1) - g
+          y = AbcDecimal(1) - b
+          k = AbcDecimal(0)
+
+          [c, m, y, k]
+        end
+
+        # Converts RGB values to CMYK using Undercolor Removal (UCR).
+        # This extracts the gray component to the black (K) channel, reducing ink usage.
+        #
+        # @param r [Numeric] Red component (0-1)
+        # @param g [Numeric] Green component (0-1)
+        # @param b [Numeric] Blue component (0-1)
+        # @param gcr_amount [Numeric] Gray Component Replacement amount (0-1), default 1.0 for full UCR
+        # @return [Array<AbcDecimal>] Array of [c, m, y, k] values
+        def from_rgb_ucr(r, g, b, gcr_amount = 1.0)
+          r = AbcDecimal(r)
+          g = AbcDecimal(g)
+          b = AbcDecimal(b)
+          gcr = AbcDecimal(gcr_amount)
+
+          # Calculate complementary CMY values
+          c = AbcDecimal(1) - r
+          m = AbcDecimal(1) - g
+          y = AbcDecimal(1) - b
+
+          # Find the minimum (gray component)
+          k = [c, m, y].min * gcr
+
+          # Remove the gray component from CMY if k > 0
+          if k.positive?
+            c -= k
+            m -= k
+            y -= k
+          end
+
+          [c, m, y, k]
+        end
+
+        # Alias for from_rgb_ucr with full GCR (the standard approach).
+        # GCR is essentially the same as UCR but allows control over how much
+        # of the gray component to extract.
+        #
+        # @param r [Numeric] Red component (0-1)
+        # @param g [Numeric] Green component (0-1)
+        # @param b [Numeric] Blue component (0-1)
+        # @param amount [Numeric] Amount of GCR to apply (0-1), default 1.0
+        # @return [Array<AbcDecimal>] Array of [c, m, y, k] values
+        def from_rgb_gcr(r, g, b, amount = 1.0)
+          from_rgb_ucr(r, g, b, amount)
+        end
+
+        # Converts CMYK values back to RGB.
+        # This is a straightforward inverse of the naive RGB→CMY conversion
+        # plus the addition of the black channel.
+        #
+        # @param c [Numeric] Cyan component (0-1)
+        # @param m [Numeric] Magenta component (0-1)
+        # @param y [Numeric] Yellow component (0-1)
+        # @param k [Numeric] Key/Black component (0-1)
+        # @return [Array<AbcDecimal>] Array of [r, g, b] values
+        def to_rgb(c, m, y, k)
+          c = AbcDecimal(c)
+          m = AbcDecimal(m)
+          y = AbcDecimal(y)
+          k = AbcDecimal(k)
+
+          # Standard CMYK to RGB conversion
+          r = (AbcDecimal(1) - c) * (AbcDecimal(1) - k)
+          g = (AbcDecimal(1) - m) * (AbcDecimal(1) - k)
+          b = (AbcDecimal(1) - y) * (AbcDecimal(1) - k)
+
+          [r, g, b]
+        end
+
+        # Calculates the Total Area Coverage (TAC) for CMYK values.
+        # TAC is the sum of all four ink percentages and is critical in print workflows
+        # to prevent excessive ink that can cause smearing or paper damage.
+        #
+        # @param c [Numeric] Cyan component (0-1)
+        # @param m [Numeric] Magenta component (0-1)
+        # @param y [Numeric] Yellow component (0-1)
+        # @param k [Numeric] Key/Black component (0-1)
+        # @return [AbcDecimal] Total ink coverage as a decimal (0-4, often expressed as 0-400%)
+        def total_area_coverage(c, m, y, k)
+          AbcDecimal(c) + AbcDecimal(m) + AbcDecimal(y) + AbcDecimal(k)
+        end
+      end
+    end
+  end
+end

data/lib/abachrome/color_models/hsv.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Abachrome::ColorModels::HSV - HSV color space model definition
 #
 # This module defines the HSV (Hue, Saturation, Value) color model within the Abachrome
@@ -30,13 +32,13 @@ module Abachrome
 
       # Validates whether the coordinates are valid for the HSV color model.
       # Each component (hue, saturation, value) must be in the range [0, 1].
-      # 
+      #
       # @param coordinates [Array<Numeric>] An array of three values representing
       # hue (h), saturation (s), and value (v) in the range [0, 1]
       # @return [Boolean] true if all coordinates are within valid ranges, false otherwise
       def valid_coordinates?(coordinates)
         h, s, v = coordinates
-        h >= 0 && h <= 1.0 &&
+        h.between?(0, 1.0) &&
           s >= 0 && s <= 1.0 &&
           v >= 0 && v <= 1.0
       end
@@ -44,4 +46,4 @@ module Abachrome
   end
 end
 
-# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/color_models/lms.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Abachrome::ColorModels::Lms - LMS color space model definition
 #
 # This module defines the LMS color model within the Abachrome color manipulation library.
@@ -33,4 +35,4 @@ ColorSpace.register(
   []
 )
 
-# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/color_models/oklab.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Abachrome::ColorModels::Oklab - OKLAB color space model definition
 #
 # This module defines the OKLAB color model within the Abachrome color manipulation library.
@@ -32,4 +34,4 @@ ColorSpace.register(
   ["ok-lab"]
 )
 
-# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/color_models/oklch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Abachrome::ColorModels::Oklch - OKLCH color space model definition
 #
 # This module defines the OKLCH color model within the Abachrome color manipulation library.
@@ -23,7 +25,7 @@ module Abachrome
   module ColorModels
     class Oklch
       # Normalizes OKLCH color values to their standard ranges.
-      # 
+      #
       # @param l [Numeric] The lightness component, will be clamped to range 0-1
       # @param c [Numeric] The chroma component, will be clamped to range 0-1
       # @param h [Numeric] The hue component in degrees, will be normalized to range 0-360
@@ -45,7 +47,7 @@ module Abachrome
       end
 
       # Converts OKLCH color coordinates to OKLab color coordinates.
-      # 
+      #
       # @param l [Numeric] The lightness value in the OKLCH color space
       # @param c [Numeric] The chroma value in the OKLCH color space
       # @param h [Numeric] The hue value in degrees in the OKLCH color space
@@ -59,7 +61,7 @@ module Abachrome
       end
 
       # Converts OKLab color coordinates to OKLCH color coordinates.
-      # 
+      #
       # @param l [Numeric] The lightness component from OKLab.
       # @param a [Numeric] The green-red component from OKLab.
       # @param b [Numeric] The blue-yellow component from OKLab.
@@ -86,4 +88,4 @@ ColorSpace.register(
   ["ok-lch"]
 )
 
-# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/color_models/rgb.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Abachrome::ColorModels::RGB - RGB color space model utilities
 #
 # This module provides utility methods for the RGB color model within the Abachrome
@@ -22,7 +24,7 @@ module Abachrome
     class RGB
       class << self
         # Normalizes RGB color component values to the [0,1] range.
-        # 
+        #
         # @param r [String, Numeric] Red component. If string with % suffix, interpreted as percentage;
         # if string without suffix or numeric > 1, interpreted as 0-255 range value;
         # if numeric ≤ 1, used directly.
@@ -53,4 +55,4 @@ module Abachrome
   end
 end
 
-# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/color_models/xyz.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Abachrome::ColorModels::Xyz - XYZ color space model definition
 #
 # This module defines the XYZ color model within the Abachrome color manipulation library.
@@ -26,4 +28,12 @@ module Abachrome
   end
 end
 
-# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.
+ColorSpace.register(
+  :xyz,
+  "XYZ",
+  %w[x y z],
+  nil,
+  []
+)
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/color_models/yiq.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Abachrome::ColorModels::YIQ - YIQ color space model utilities
+#
+# This module provides utility methods for the YIQ color model within the Abachrome
+# color manipulation library. YIQ is a color space historically used by the NTSC
+# television standard, separating luminance (Y) from chrominance (I and Q).
+#
+# Key features:
+# - Separates brightness (luma) from color information
+# - Y (luma): Weighted sum of RGB based on human eye sensitivity
+# - I (In-phase): Orange-to-blue axis
+# - Q (Quadrature): Purple-to-green axis
+# - Supports legacy broadcast standards and computer vision applications
+# - Uses Rec. 601 coefficients for luma calculation
+#
+# The YIQ model is essential for image processing algorithms that need to separate
+# luminance from chrominance, including JPEG compression, grayscale conversion, and
+# edge detection in computer vision applications.
+
+module Abachrome
+  module ColorModels
+    class YIQ
+      class << self
+        # Normalizes YIQ color component values to their standard ranges.
+        #
+        # @param y [Numeric] Luma component (brightness), typically in range [0,1]
+        # @param i [Numeric] In-phase component (orange-blue), typically in range [-0.5957, 0.5957]
+        # @param q [Numeric] Quadrature component (purple-green), typically in range [-0.5226, 0.5226]
+        # @return [Array<AbcDecimal>] Array of three normalized components as AbcDecimal objects
+        def normalize(y, i, q)
+          [y, i, q].map { |value| AbcDecimal(value) }
+        end
+      end
+    end
+  end
+end