abachrome-float 0.1.6

data/lib/abachrome/color_models/xyz.rb

@@ -0,0 +1,31 @@
+# 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.
+# XYZ 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. The XYZ color space represents
+# colors using tristimulus values that correspond to the response of the human visual system
+# to light stimuli, making it fundamental to color science and accurate color reproduction.
+#
+# Key features:
+# - Registers the XYZ color space with coordinate names [x, y, z]
+# - Represents tristimulus values for device-independent color specification
+# - Serves as intermediate color space for conversions between different color models
+# - Uses normalized values for consistency with other color models in the library
+# - Maintains high precision through AbcDecimal arithmetic for color transformations
+# - Provides validation for XYZ coordinate ranges to ensure valid color representations
+#
+# The XYZ model is particularly important in the color science pipeline as it provides
+# a standardized reference for color matching and serves as the foundation for defining
+# other color spaces like LAB, making it essential for accurate color transformations
+# that maintain consistency across different devices and viewing conditions.
+
+module Abachrome
+  module ColorModels
+    class Xyz
+    end
+  end
+end
+
+# 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| value.to_f }
+        end
+      end
+    end
+  end
+end

data/lib/abachrome/color_space.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+# Abachrome::ColorSpace - Core color space definition and registry system
+#
+# This module provides the foundation for managing color spaces within the Abachrome library.
+# It implements a registry system for storing and retrieving color space definitions, along
+# with the ColorSpace class that encapsulates color space properties including coordinate
+# names, white points, and color models.
+#
+# Key features:
+# - Global registry for color space registration and lookup with alias support
+# - Color space definition with configurable coordinates, white points, and color models
+# - Built-in registration of standard color spaces (sRGB, linear RGB, HSL, LAB, OKLAB, OKLCH)
+# - Equality comparison and hash support for color space objects
+# - Flexible initialization through block-based configuration
+# - Support for color space aliases (e.g., :rgb as alias for :srgb)
+#
+# The ColorSpace class serves as the foundation for the Color class and converter system,
+# providing the metadata needed for proper color representation and transformation between
+# different color spaces. All registered color spaces are accessible through the registry
+# class methods and can be extended with custom color space definitions.
+
+module Abachrome
+  class ColorSpace
+    class << self
+      # A registry of all registered color spaces.
+      #
+      # @return [Hash] A memoized hash where keys are color space identifiers and values are the corresponding color space objects
+      def registry
+        @registry ||= {}
+      end
+
+      # Registers a new color space with the specified name.
+      #
+      # @param name [String, Symbol] The identifier for the color space
+      # @param block [Proc] A block that configures the color space properties
+      # @return [Abachrome::ColorSpace] The newly created color space instance added to the registry
+      def register(name, &block)
+        registry[name.to_sym] = new(name, &block)
+      end
+
+      # Aliases a color space name to an existing registered color space.
+      #
+      # This method creates an alias for an existing color space in the registry,
+      # allowing the same color space to be accessed through multiple names.
+      #
+      # @param name [Symbol, String] The existing color space name already registered
+      # @param aliased_name [Symbol, String] The new alias name to register
+      # @return [void]
+      def alias(name, aliased_name)
+        registry[aliased_name.to_sym] = registry[name.to_sym]
+      end
+
+      # @param name [String, Symbol] The name of the color space to find
+      # @return [Abachrome::ColorSpace] The color space with the given name
+      # @raise [ArgumentError] If no color space with the given name exists in the registry
+      def find(name)
+        registry[name.to_sym] or raise ArgumentError, "Unknown color space: #{name}"
+      end
+    end
+
+    attr_reader :name, :coordinates, :white_point, :color_model
+
+    # Initialize a new ColorSpace instance.
+    #
+    # @param name [String, Symbol] The name of the color space, which will be converted to a symbol
+    # @return [Abachrome::ColorSpace] A new instance of ColorSpace
+    # @yield [self] Yields self to the block for configuration if a block is given
+    def initialize(name)
+      @name = name.to_sym
+      yield self if block_given?
+    end
+
+    # Sets the color coordinates for the current color space.
+    #
+    # @param [Array] coords The coordinate values that define a color in this color space.
+    # Multiple arguments or a single flat array can be provided.
+    # @return [Array] The flattened array of coordinates.
+    def coordinates=(*coords)
+      @coordinates = coords.flatten
+    end
+
+    # Sets the white point reference used by the color space.
+    #
+    # The white point is a reference that defines what is considered "white" in a color space.
+    # Common values include :D50, :D65, etc.
+    #
+    # @param point [Symbol, String] The white point reference to use (will be converted to Symbol)
+    # @return [Symbol] The newly set white point
+    def white_point=(point)
+      @white_point = point.to_sym
+    end
+
+    # Sets the color model for the color space.
+    #
+    # @param model [String, Symbol] The new color model to set for this color space
+    # @return [Symbol] The color model as a symbolized value
+    def color_model=(model)
+      @color_model = model.to_sym
+    end
+
+    # Compares this ColorSpace instance with another to check for equality.
+    #
+    # Two ColorSpace objects are considered equal if they have the same name.
+    #
+    # @param other [Object] The object to compare against
+    # @return [Boolean] true if other is a ColorSpace with the same name, false otherwise
+    def ==(other)
+      return false unless other.is_a?(ColorSpace)
+
+      name == other.name
+    end
+
+    # Checks if two color spaces are equal.
+    #
+    # @param other [Abachrome::ColorSpace] The color space to compare with
+    # @return [Boolean] true if the color spaces are equal, false otherwise
+    def eql?(other)
+      self == other
+    end
+
+    # Returns a hash value for the color space based on its name.
+    #
+    # @return [Integer] A hash value computed from the color space name that can be
+    # used for equality comparison and as a hash key.
+    def hash
+      name.hash
+    end
+
+    # Returns the identifier for the color space, which is currently the same as its name.
+    # @return [String, Symbol] the identifier of the color space
+    def id
+      name
+    end
+  end
+
+  ColorSpace.register(:srgb) do |s|
+    s.coordinates = %i[red green blue]
+    s.white_point = :D65
+    s.color_model = :srgb
+  end
+  ColorSpace.alias(:srgb, :rgb)
+
+  ColorSpace.register(:lrgb) do |s|
+    s.coordinates = %i[red green blue]
+    s.white_point = :D65
+    s.color_model = :lrgb
+  end
+
+  ColorSpace.register(:hsl) do |s|
+    s.coordinates = %i[hue saturation lightness]
+    s.white_point = :D65
+    s.color_model = :hsl
+  end
+
+  ColorSpace.register(:lab) do |s|
+    s.coordinates = %i[lightness a b]
+    s.white_point = :D65
+    s.color_model = :lab
+  end
+
+  ColorSpace.register(:oklab) do |s|
+    s.coordinates = %i[lightness a b]
+    s.white_point = :D65
+    s.color_model = :oklab
+  end
+
+  ColorSpace.register(:oklch) do |s|
+    s.coordinates = %i[lightness chroma hue]
+    s.white_point = :D65
+    s.color_model = :oklch
+  end
+
+  ColorSpace.register(:xyz) do |s|
+    s.coordinates = %i[x y z]
+    s.white_point = :D65
+    s.color_model = :xyz
+  end
+
+  ColorSpace.register(:lms) do |s|
+    s.coordinates = %i[l m s]
+    s.white_point = :D65
+    s.color_model = :lms
+  end
+
+  ColorSpace.register(:yiq) do |s|
+    s.coordinates = %i[y i q]
+    s.white_point = :D65
+    s.color_model = :yiq
+  end
+
+  ColorSpace.register(:cmyk) do |s|
+    s.coordinates = %i[cyan magenta yellow key]
+    s.white_point = :D50
+    s.color_model = :cmyk
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converter.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+# Abachrome::Converter - Color space conversion registry and orchestration system
+#
+# This module provides the central registry and conversion orchestration for transforming colors
+# between different color spaces within the Abachrome library. It manages a registry of converter
+# classes that handle transformations between specific color space pairs (e.g., sRGB to OKLAB,
+# OKLCH to linear RGB) and provides the main conversion interface used throughout the library.
+#
+# Key features:
+# - Global registry for color space converter registration with automatic discovery
+# - Converter lookup and routing between source and target color spaces
+# - Automatic registration of all converter classes found in the Converters namespace
+# - Conversion orchestration that finds appropriate converters based on color model compatibility
+# - Support for multi-step conversions through intermediate color spaces when needed
+# - Integration with the ColorSpace system for proper color space identification
+#
+# The Converter system serves as the backbone for all color transformations in Abachrome,
+# enabling seamless conversion between any registered color spaces while maintaining the
+# precision and accuracy required for color science calculations. Converter classes follow
+# a naming convention (FromSpaceToSpace) for automatic registration and discovery.
+
+module Abachrome
+  class Converter
+    class << self
+      # Returns the registry hash used to store color space converters.
+      #
+      # This method lazily initializes and returns the hash used internally to store
+      # converter mappings between different color spaces. This registry is a central
+      # repository that maps color space pairs to their appropriate conversion functions.
+      #
+      # @return [Hash] The converter registry hash, mapping color space pairs to converter functions
+      def registry
+        @registry ||= {}
+      end
+
+      # Register a converter class for transforming colors between two specific color spaces.
+      #
+      # @param from_space [Symbol, String] The source color space identifier
+      # @param to_space [Symbol, String] The destination color space identifier
+      # @param converter_class [Class] The converter class that implements the transformation
+      # @return [Class] The registered converter class
+      def register(from_space, to_space, converter_class)
+        registry[[from_space.to_s, to_space.to_s]] = converter_class
+      end
+
+      # Converts a color from its current color space to the specified target color space.
+      #
+      # @param color [Abachrome::Color] The color to convert
+      # @param to_space_name [String, Symbol] The name of the target color space
+      # @return [Abachrome::Color] The color converted to the target color space
+      # @raise [RuntimeError] If no converter is found between the source and target color models
+      def convert(color, to_space_name)
+        to_space = ColorSpace.find(to_space_name)
+        return color if color.color_space == to_space
+
+        # convert model first
+        to_model = to_space.color_model
+        converter = find_converter(color.color_space.color_model, to_model.to_s)
+        raise "No converter found from #{color.color_space.color_model} to #{to_model}" unless converter
+
+        converter.convert(color)
+      end
+
+      # @api private
+      # @since 0.1.0
+      # @example
+      # converter = Abachrome::Converter.new
+      # converter.register_all_converters
+      #
+      # Automatically registers all converter classes found in the Converters namespace.
+      # The method iterates through constants in the Converters module, identifies classes
+      # with naming pattern "FromSpaceToSpace" (e.g., LrgbToOklab), extracts the source
+      # and destination color spaces from the class name, and registers the converter
+      # class for the corresponding color space conversion.
+      #
+      # @return [void]
+      def register_all_converters
+        Converters.constants.each do |const_name|
+          const = Converters.const_get(const_name)
+          next unless const.is_a?(Class)
+
+          # Parse from_space and to_space from class name (e.g., LrgbToOklab)
+          next unless const_name.to_s =~ /^(.+)To(.+)$/
+
+          from_space = ::Regexp.last_match(1).downcase.to_sym
+          to_space = ::Regexp.last_match(2).downcase.to_sym
+
+          # Register the converter
+          register(from_space, to_space, const)
+        end
+      end
+
+      private
+
+      # Retrieves a converter function between two color spaces from the registry.
+      #
+      # @param from_space_name [String, Symbol] The source color space name
+      # @param to_space_name [String, Symbol] The target color space name
+      # @return [Proc, nil] The conversion function if registered, or nil if no converter exists for the specified color spaces
+      def find_converter(from_space_name, to_space_name)
+        registry[[from_space_name.to_s, to_space_name.to_s]]
+      end
+    end
+  end
+
+  # Load all converter files
+  converters_path = File.join(__dir__, "converters", "*.rb")
+  Dir[converters_path].each do |file|
+    require file
+  end
+
+  # Auto-register all converters
+  Converter.register_all_converters
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/base.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+# Abachrome::Converters::Base - Abstract base class for color space converters
+#
+# This class provides the foundation for implementing color space conversion functionality
+# within the Abachrome library. It defines the interface that all converter classes must
+# implement and provides common validation and utility methods for color transformations.
+#
+# Key features:
+# - Abstract conversion interface requiring subclasses to implement #convert method
+# - Color model validation to ensure proper conversion compatibility
+# - Converter registration and lookup system for managing conversion mappings
+# - Source and target color space compatibility checking
+# - Base functionality for building specific converter implementations
+#
+# All converter classes in the Abachrome system inherit from this base class and implement
+# the specific mathematical transformations needed to convert colors between different
+# color spaces such as sRGB, OKLAB, OKLCH, and linear RGB. The class follows a naming
+# convention pattern (FromSpaceToSpace) for automatic registration and discovery.
+
+module Abachrome
+  module Converters
+    class Base
+      attr_reader :from_space, :to_space
+
+      # Initialize a new converter between two color spaces.
+      #
+      # @param from_space [Abachrome::ColorSpace] The source color space to convert from
+      # @param to_space [Abachrome::ColorSpace] The target color space to convert to
+      # @return [Abachrome::Converters::Base] A new converter instance
+      def initialize(from_space, to_space)
+        @from_space = from_space
+        @to_space = to_space
+      end
+
+      # Converts a color from one color space to another.
+      #
+      # @abstract This is an abstract method that must be implemented by subclasses.
+      # @param color [Abachrome::Color] The color to convert
+      # @return [Abachrome::Color] The converted color
+      # @raise [NotImplementedError] If the subclass doesn't implement this method
+      def convert(color)
+        raise NotImplementedError, "Subclasses must implement #convert"
+      end
+
+      # Validates that a color uses the expected color model.
+      #
+      # @param color [Abachrome::Color] The color object to check
+      # @param model [Symbol, String] The expected color model
+      # @raise [RuntimeError] If the color's model doesn't match the expected model
+      # @return [nil] If the color's model matches the expected model
+      def self.raise_unless(color, model)
+        return if color.color_space.color_model == model
+
+        raise "#{color} is #{color.color_space.color_model}), expecting #{model}"
+      end
+
+      # Determines if the converter can handle the given color.
+      #
+      # This method checks if the color's current color space matches
+      # the converter's source color space.
+      #
+      # @param color [Abachrome::Color] The color to check
+      # @return [Boolean] true if the converter can convert from the color's current color space,
+      # false otherwise
+      def can_convert?(color)
+        color.color_space == from_space
+      end
+
+      # Register a converter class for transforming colors between two specific color spaces.
+      #
+      # @param from_space_id [Symbol] The identifier of the source color space
+      # @param to_space_id [Symbol] The identifier of the destination color space
+      # @param converter_class [Class] The converter class that handles the transformation
+      # @return [void]
+      def self.register(from_space_id, to_space_id, converter_class)
+        @converters ||= {}
+        @converters[[from_space_id, to_space_id]] = converter_class
+      end
+
+      # Find a converter for converting between color spaces.
+      #
+      # @param from_space_id [Symbol, String] The identifier of the source color space
+      # @param to_space_id [Symbol, String] The identifier of the destination color space
+      # @return [Converter, nil] The converter instance for the specified color spaces, or nil if no converter is found
+      def self.find_converter(from_space_id, to_space_id)
+        @converters ||= {}
+        @converters[[from_space_id, to_space_id]]
+      end
+
+      # Converts a color from its current color space to a target color space.
+      #
+      # This method finds the appropriate converter class for the given source and
+      # target color spaces and performs the conversion.
+      #
+      # @param color [Abachrome::Color] The color to convert
+      # @param to_space [Abachrome::ColorSpace] The target color space to convert to
+      # @return [Abachrome::Color] The converted color in the target color space
+      # @raise [ConversionError] If no converter is found for the given color spaces
+      def self.convert(color, to_space)
+        converter_class = find_converter(color.color_space.id, to_space.id)
+        unless converter_class
+          raise ConversionError,
+                "No converter found from #{color.color_space.name} to #{to_space.name}"
+        end
+
+        converter = converter_class.new(color.color_space, to_space)
+        converter.convert(color)
+      end
+
+      private
+
+      # Validates if a color can be converted from its current color space.
+      # Raises an ArgumentError if the color's space doesn't match the expected source space.
+      #
+      # @param color [Abachrome::Color] The color object to validate
+      # @raise [ArgumentError] If the color cannot be converted from its current color space
+      # @return [nil] Returns nil if the color is valid for conversion
+      def validate_color!(color)
+        return if can_convert?(color)
+
+        raise ArgumentError, "Cannot convert color from #{color.color_space.name} (expected #{from_space.name})"
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/cmyk_to_srgb.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Abachrome::Converters::CmykToSrgb - CMYK to sRGB color space converter
+#
+# This converter transforms colors from the CMYK (Cyan, Magenta, Yellow, Key/Black)
+# color space back to the standard RGB (sRGB) color space for display on screens.
+#
+# Key features:
+# - Implements the standard CMYK to RGB conversion algorithm
+# - Converts from subtractive (ink) to additive (light) color model
+# - Maintains alpha channel transparency values during conversion
+# - Uses BigDecimal arithmetic for precise color science calculations
+# - Handles colors created with UCR/GCR correctly
+#
+# The conversion recombines the ink components (CMYK) back into light components (RGB)
+# using the standard inverse transformation. Note that some CMYK colors may be
+# out of gamut for sRGB displays.
+
+module Abachrome
+  module Converters
+    class CmykToSrgb
+      # Converts a color from CMYK color space to sRGB color space.
+      # This method applies the standard CMYK to RGB transformation.
+      #
+      # @param cmyk_color [Abachrome::Color] A color object in the CMYK color space
+      # @return [Abachrome::Color] A new color object in the sRGB color space
+      # with the same alpha value as the input color
+      def self.convert(cmyk_color)
+        c, m, y, k = cmyk_color.coordinates.map { |component| component.to_f }
+
+        # Use the CMYK color model's conversion method
+        r, g, b = ColorModels::CMYK.to_rgb(c, m, y, k)
+
+        Color.new(
+          ColorSpace.find(:srgb),
+          [r, g, b],
+          cmyk_color.alpha
+        )
+      end
+    end
+  end
+end

data/lib/abachrome/converters/lms_to_lrgb.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module Converters
+    class LmsToLrgb < Abachrome::Converters::Base
+      # Converts a color from LMS color space to linear RGB color space.
+      #
+      # This method implements the final part of the OKLAB to linear RGB transformation,
+      # converting LMS (Long, Medium, Short) coordinates to linear RGB coordinates
+      # using the standard transformation matrix. 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 linear RGB color space with
+      # the same alpha as the input color
+      def self.convert(lms_color)
+        raise_unless lms_color, :lms
+
+        l, m, s = lms_color.coordinates.map { |_| _.to_f }
+
+        r = (l * AD("4.07674166134799")) +
+            (m * AD("-3.307711590408193")) +
+            (s * AD("0.230969928729428"))
+        g = (l * AD("-1.2684380040921763")) +
+            (m * AD("2.6097574006633715")) +
+            (s * AD("-0.3413193963102197"))
+        b = (l * AD("-0.004196086541837188")) +
+            (m * AD("-0.7034186144594493")) +
+            (s * AD("1.7076147009309444"))
+
+        output_coords = [r, g, b].map { |it| [it, 0].max }
+
+        Color.new(ColorSpace.find(:lrgb), output_coords, lms_color.alpha)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/lms_to_srgb.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module Converters
+    class LmsToSrgb < Abachrome::Converters::Base
+      # Converts a color from LMS color space to sRGB color space.
+      #
+      # This method implements a two-step conversion process:
+      # 1. First converts from LMS to linear RGB using the standard transformation matrix
+      # 2. Then converts from linear RGB to sRGB by applying gamma correction
+      #
+      # @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 sRGB color space with
+      # the same alpha as the input color
+      def self.convert(lms_color)
+        # First convert LMS to linear RGB
+        lrgb_color = LmsToLrgb.convert(lms_color)
+
+        # Then convert linear RGB to sRGB
+        LrgbToSrgb.convert(lrgb_color)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/lms_to_xyz.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Abachrome
+  module Converters
+    class LmsToXyz < Abachrome::Converters::Base
+      # Converts a color from LMS color space to XYZ color space.
+      #
+      # This method implements the LMS to XYZ transformation using the standard
+      # transformation matrix. The LMS color space represents the response of
+      # the three types of cone cells in the human eye (Long, Medium, Short),
+      # while XYZ is the CIE 1931 color space that forms the basis for most
+      # other color space definitions.
+      #
+      # @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 XYZ color space with
+      # the same alpha as the input color
+      def self.convert(lms_color)
+        raise_unless lms_color, :lms
+
+        l, m, s = lms_color.coordinates.map { |_| _.to_f }
+
+        # LMS to XYZ transformation matrix
+        x = (l * AD("1.86006661")) - (m * AD("1.12948190")) + (s * AD("0.21989740"))
+        y = (l * AD("0.36122292")) + (m * AD("0.63881308")) - (s * AD("0.00000000"))
+        z = (l * AD("0.00000000")) - (m * AD("0.00000000")) + (s * AD("1.08906362"))
+
+        Color.new(ColorSpace.find(:xyz), [x, y, z], lms_color.alpha)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/lrgb_to_lms.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.