kodachroma 1.0.0

data/lib/kodachroma/converters/base.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module Kodachroma
+  module Converters
+    # Base class for converting one color mode to another.
+    # @abstract
+    class Base
+      include Helpers::Bounders
+
+      # @param input [ColorModes::Rgb, ColorModes::Hsl, ColorModes::Hsv]
+      # @return [Base]
+      def initialize(input)
+        @input = input
+      end
+
+      # @param rgb [ColorModes::Rgb]
+      # @return [ColorModes::Rgb, ColorModes::Hsl, ColorModes::Hsv]
+      def self.convert_rgb(rgb)
+        new(rgb).convert_rgb
+      end
+
+      # @param hsl [ColorModes::Hsl]
+      # @return [ColorModes::Rgb, ColorModes::Hsl, ColorModes::Hsv]
+      def self.convert_hsl(hsl)
+        new(hsl).convert_hsl
+      end
+
+      # @param hsv [ColorModes::Hsv]
+      # @return [ColorModes::Rgb, ColorModes::Hsl, ColorModes::Hsv]
+      def self.convert_hsv(hsv)
+        new(hsv).convert_hsv
+      end
+    end
+  end
+end

data/lib/kodachroma/converters/hsl_converter.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+module Kodachroma
+  module Converters
+    # Class to convert a color mode to {ColorModes::Hsl}.
+    class HslConverter < Base
+      # Convert rgb to hsl.
+      # @return [ColorModes::Hsl]
+      def convert_rgb
+        r = bound01(@input.r, 255)
+        g = bound01(@input.g, 255)
+        b = bound01(@input.b, 255)
+
+        rgb_array = [r, g, b]
+
+        max = rgb_array.max
+        min = rgb_array.min
+        l = (max + min) * 0.5
+
+        if max == min
+          h = s = 0
+        else
+          d = (max - min).to_f
+
+          s = if l > 0.5
+                d / (2 - max - min)
+              else
+                d / (max + min)
+              end
+
+          h = case max
+              when r then ((g - b) / d) + (g < b ? 6 : 0)
+              when g then ((b - r) / d) + 2
+              when b then ((r - g) / d) + 4
+              end
+
+          h /= 6.0
+        end
+
+        ColorModes::Hsl.new(h * 360, s, l, @input.a)
+      end
+
+      # Returns @input because it's the same color mode.
+      # @return [ColorModes::Hsl]
+      def convert_hsl
+        @input
+      end
+
+      # Convert hsv to hsl.
+      # @return [ColorModes::Hsl]
+      def convert_hsv
+        HsvConverter.convert_rgb(RgbConverter.convert_hsl(@input))
+      end
+    end
+  end
+end

data/lib/kodachroma/converters/hsv_converter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Kodachroma
+  module Converters
+    # Class to convert a color mode to {ColorModes::Hsl}.
+    class HsvConverter < Base
+      # Convert rgb to hsv.
+      # @return [ColorModes::Hsv]
+      def convert_rgb
+        r = bound01(@input.r, 255)
+        g = bound01(@input.g, 255)
+        b = bound01(@input.b, 255)
+
+        rgb_array = [r, g, b]
+
+        max = rgb_array.max
+        min = rgb_array.min
+        v = max
+        d = (max - min).to_f
+        s = max.zero? ? 0 : d / max
+
+        if max == min
+          h = 0
+        else
+          h = case max
+              when r then ((g - b) / d) + (g < b ? 6 : 0)
+              when g then ((b - r) / d) + 2
+              when b then ((r - g) / d) + 4
+              end
+
+          h /= 6.0
+        end
+
+        ColorModes::Hsv.new(h * 360, s, v, @input.a)
+      end
+
+      # Convert hsl to hsv.
+      # @return [ColorModes::Hsv]
+      def convert_hsl
+        HslConverter.convert_rgb(RgbConverter.convert_hsv(@input))
+      end
+
+      # Returns @input because it's the same color mode.
+      # @return [ColorModes::Hsv]
+      def convert_hsv
+        @input
+      end
+    end
+  end
+end

data/lib/kodachroma/converters/rgb_converter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+module Kodachroma
+  module Converters
+    # Class to convert a color mode to {ColorModes::Rgb}.
+    class RgbConverter < Base
+      # Returns @input because it's the same color mode.
+      # @return [ColorModes::Rgb]
+      def convert_rgb
+        @input
+      end
+
+      # Convert hsl to rgb.
+      # @return [ColorModes::Rgb]
+      def convert_hsl
+        h, s, l = @input
+
+        h = bound01(h, 360)
+        s = bound01(s, 100)
+        l = bound01(l, 100)
+
+        if s.zero?
+          r = g = b = l * 255
+        else
+          q = l < 0.5 ? l * (1 + s) : l + s - (l * s)
+          p = (2 * l) - q
+          r = hue_to_rgb(p, q, h + (1 / 3.0)) * 255
+          g = hue_to_rgb(p, q, h) * 255
+          b = hue_to_rgb(p, q, h - (1 / 3.0)) * 255
+        end
+
+        ColorModes::Rgb.new(r, g, b, bound_alpha(@input.a))
+      end
+
+      # Convert hsv to rgb.
+      # @return [ColorModes::Rgb]
+      def convert_hsv
+        h, s, v = @input
+
+        h = bound01(h, 360) * 6
+        s = bound01(s, 100)
+        v = bound01(v, 100)
+
+        i = h.floor
+        f = h - i
+        p = v * (1 - s)
+        q = v * (1 - (f * s))
+        t = v * (1 - ((1 - f) * s))
+        mod = i % 6
+
+        r = [v, q, p, p, t, v][mod] * 255
+        g = [t, v, v, q, p, p][mod] * 255
+        b = [p, p, t, v, v, q][mod] * 255
+
+        ColorModes::Rgb.new(r, g, b, bound_alpha(@input.a))
+      end
+
+      private
+
+      def hue_to_rgb(p, q, t)
+        if t.negative? then t += 1
+        elsif t > 1 then t -= 1
+        end
+
+        if    t < 1 / 6.0 then p + ((q - p) * 6 * t)
+        elsif t < 0.5 then q
+        elsif t < 2 / 3.0 then p + ((q - p) * ((2 / 3.0) - t) * 6)
+        else p
+        end
+      end
+    end
+  end
+end

data/lib/kodachroma/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Kodachroma
+  module Errors
+    class PaletteDefinedError < StandardError; end
+
+    class UnrecognizedColor < StandardError; end
+  end
+end

data/lib/kodachroma/harmonies.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+module Kodachroma
+  # Class to hold all palette methods.
+  class Harmonies
+    # @param color [Color]
+    def initialize(color)
+      @color = color
+    end
+
+    # Generate a complement palette.
+    #
+    # @example
+    #   'red'.paint.palette.complement            #=> [red, cyan]
+    #   'red'.paint.palette.complement(as: :name) #=> ['red', 'cyan']
+    #   'red'.paint.palette.complement(as: :hex)  #=> ['#ff0000', '#00ffff']
+    #
+    # @param options [Hash]
+    # @option options :as [Symbol] (nil) optional format to output colors as strings
+    # @return [Array<Color>, Array<String>] depending on presence of `options[:as]`
+    def complement(options = {})
+      with_reformat([@color, @color.complement], options[:as])
+    end
+
+    # Generate a triad palette.
+    #
+    # @example
+    #   'red'.paint.palette.triad            #=> [red, lime, blue]
+    #   'red'.paint.palette.triad(as: :name) #=> ['red', 'lime', 'blue']
+    #   'red'.paint.palette.triad(as: :hex)  #=> ['#ff0000', '#00ff00', '#0000ff']
+    #
+    # @param options [Hash]
+    # @option options :as [Symbol] (nil) optional format to output colors as strings
+    # @return [Array<Color>, Array<String>] depending on presence of `options[:as]`
+    def triad(options = {})
+      hsl_map([0, 120, 240], options)
+    end
+
+    # Generate a tetrad palette.
+    #
+    # @example
+    #   'red'.paint.palette.tetrad            #=> [red, #80ff00, cyan, #7f00ff]
+    #   'red'.paint.palette.tetrad(as: :name) #=> ['red', '#80ff00', 'cyan', '#7f00ff']
+    #   'red'.paint.palette.tetrad(as: :hex)  #=> ['#ff0000', '#80ff00', '#00ffff', '#7f00ff']
+    #
+    # @param options [Hash]
+    # @option options :as [Symbol] (nil) optional format to output colors as strings
+    # @return [Array<Color>, Array<String>] depending on presence of `options[:as]`
+    def tetrad(options = {})
+      hsl_map([0, 90, 180, 270], options)
+    end
+
+    # Generate a split complement palette.
+    #
+    # @example
+    #   'red'.paint.palette.split_complement            #=> [red, #ccff00, #0066ff]
+    #   'red'.paint.palette.split_complement(as: :name) #=> ['red', '#ccff00', '#0066ff']
+    #   'red'.paint.palette.split_complement(as: :hex)  #=> ['#ff0000', '#ccff00', '#0066ff']
+    #
+    # @param options [Hash]
+    # @option options :as [Symbol] (nil) optional format to output colors as strings
+    # @return [Array<Color>, Array<String>] depending on presence of `options[:as]`
+    def split_complement(options = {})
+      hsl_map([0, 72, 216], options)
+    end
+
+    # Generate an analogous palette.
+    #
+    # @example
+    #   'red'.paint.palette.analogous                        #=> [red, #ff0066, #ff0033, red, #ff3300, #ff6600]
+    #   'red'.paint.palette.analogous(as: :hex)              #=> ['#f00', '#f06', '#f03', '#f00', '#f30', '#f60']
+    #   'red'.paint.palette.analogous(size: 3)               #=> [red, #ff001a, #ff1a00]
+    #   'red'.paint.palette.analogous(size: 3, slice_by: 60) #=> [red, #ff000d, #ff0d00]
+    #
+    # @param options [Hash]
+    # @option options :size     [Symbol] (6) number of results to return
+    # @option options :slice_by [Symbol] (30)
+    #   the angle in degrees to slice the hue circle per color
+    # @option options :as       [Symbol] (nil) optional format to output colors as strings
+    # @return [Array<Color>, Array<String>] depending on presence of `options[:as]`
+    def analogous(options = {})
+      size = options[:size] || 6
+      slices = options[:slice_by] || 30
+
+      hsl = @color.hsl
+      part = 360 / slices
+      hsl.h = ((hsl.h - ((part * size) >> 1)) + 720) % 360
+
+      palette = (size - 1).times.reduce([@color]) do |arr, _n|
+        hsl.h = (hsl.h + part) % 360
+        arr << Color.new(hsl, @color.format)
+      end
+
+      with_reformat(palette, options[:as])
+    end
+
+    # Generate a monochromatic palette.
+    #
+    # @example
+    #   'red'.paint.palette.monochromatic           #=> [red, #2a0000, #550000, maroon, #aa0000, #d40000]
+    #   'red'.paint.palette.monochromatic(as: :hex) #=> ['#ff0000', '#2a0000', '#550000', '#800000', '#aa0000', '#d40000']
+    #   'red'.paint.palette.monochromatic(size: 3)  #=> [red, #550000, #aa0000]
+    #
+    # @param options [Hash]
+    # @option options :size [Symbol] (6) number of results to return
+    # @option options :as   [Symbol] (nil) optional format to output colors as strings
+    # @return [Array<Color>, Array<String>] depending on presence of `options[:as]`
+    def monochromatic(options = {})
+      size = options[:size] || 6
+
+      h, s, v = @color.hsv
+      modification = 1.0 / size
+
+      palette = size.times.map do
+        Color.new(ColorModes::Hsv.new(h, s, v), @color.format).tap do
+          v = (v + modification) % 1
+        end
+      end
+
+      with_reformat(palette, options[:as])
+    end
+
+    private
+
+    def with_reformat(palette, as)
+      palette.map! { |color| color.to_s(as) } unless as.nil?
+      palette
+    end
+
+    def hsl_map(degrees, options)
+      h, s, l = @color.hsl
+
+      degrees.map! do |deg|
+        Color.new(ColorModes::Hsl.new((h + deg) % 360, s, l), @color.format)
+      end
+
+      with_reformat(degrees, options[:as])
+    end
+  end
+end

data/lib/kodachroma/helpers/bounders.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module Kodachroma
+  module Helpers
+    module Bounders
+      # Bounds a value `n` that is from `0` to `max` to `0` to `1`.
+      #
+      # @param n   [Numeric, String]
+      # @param max [Fixnum]
+      # @return    [Float]
+      def bound01(n, max)
+        is_percent = n.to_s.include? '%'
+        n = [max, [0, n.to_f].max].min
+        n = (n * max).to_i / 100.0 if is_percent
+
+        return 1 if (n - max).abs < 0.000001
+
+        (n % max) / max.to_f
+      end
+
+      # Ensure alpha value `a` is between `0` and `1`.
+      #
+      # @param a [Numeric, String] alpha value
+      # @return  [Numeric]
+      def bound_alpha(a)
+        a = a.to_f
+        a = 1 if a.negative? || a > 1
+        a
+      end
+
+      # Ensures a number between `0` and `1`. Returns `n` if it is between `0`
+      #   and `1`.
+      #
+      # @param n [Numeric]
+      # @return  [Numeric]
+      def clamp01(n)
+        [1, [0, n].max].min
+      end
+
+      # Converts `n` to a percentage type value.
+      #
+      # @param n [Numeric, String]
+      # @return  [String, Float]
+      def to_percentage(n)
+        n = n.to_f
+        n = "#{ n * 100 }%" if n <= 1
+        n
+      end
+    end
+  end
+end

data/lib/kodachroma/palette_builder.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+module Kodachroma
+  # Class internally used to build custom palettes from {Kodachroma.define_palette}.
+  class PaletteBuilder
+    # Wrapper to instantiate a new instance of {PaletteBuilder} and call its
+    #   {PaletteBuilder#build} method.
+    #
+    # @param block [Proc]                             the palette definition block
+    # @return      [PaletteBuilder::PaletteEvaluator] lazy palette generator
+    def self.build(&block)
+      new(&block).build
+    end
+
+    # @param block [Proc] the palette definition block
+    def initialize(&block)
+      @block = block
+    end
+
+    # Build the custom palette
+    # @return [PaletteBuilder::PaletteEvaluator] lazy palette generator
+    def build
+      dsl = PaletteBuilderDsl.new
+      dsl.instance_eval(&@block)
+      dsl.evaluator
+    end
+
+    # Internal class for delaying evaluating a color to generate a
+    # final palette
+    class PaletteEvaluator
+      def initialize
+        @conversions = []
+      end
+
+      def <<(conversion)
+        @conversions << conversion
+      end
+
+      def evaluate(color)
+        @conversions.map do |color_calls|
+          color_calls.evaluate(color)
+        end.unshift(color)
+      end
+    end
+
+    # Internal class for palette building DSL syntax.
+    class PaletteBuilderDsl
+      attr_reader :evaluator
+
+      def initialize
+        @evaluator = PaletteEvaluator.new
+      end
+
+      def method_missing(name, *args)
+        ColorCalls.new(name, args).tap do |color_calls|
+          @evaluator << color_calls
+        end
+      end
+
+      # Internal class to represent color modification calls in the palette
+      # builder DSL definition syntax.
+      class ColorCalls
+        attr_reader :name, :args
+
+        def initialize(name, args)
+          @calls = [[name, args]]
+        end
+
+        def evaluate(color)
+          @calls.reduce(color) do |c, (name, args)|
+            c.send(name, *args)
+          end
+        end
+
+        def method_missing(name, *args)
+          @calls << [name, args]
+        end
+      end
+    end
+  end
+end