color_lib 1.4.4

data/lib/color_lib/palette/adobecolor.rb

@@ -0,0 +1,265 @@
+require 'color_lib/palette'
+# A class that can read an Adobe ColorLib palette file (used for Photoshop
+# swatches) and provide a Hash-like interface to the contents. Not all
+# colour formats in ACO files are supported. Based largely off the
+# information found by Larry Tesler[http://www.nomodes.com/aco.html].
+#
+# Not all Adobe ColorLib files have named colours; all named entries are
+# returned as an array.
+#
+#   pal = ColorLib::Palette::AdobeColorLib.from_file(my_aco_palette)
+#   pal[0]          => ColorLib::RGB<...>
+#   pal["white"]    => [ ColorLib::RGB<...> ]
+#   pal["unknown"]  => [ ColorLib::RGB<...>, ColorLib::RGB<...>, ... ]
+#
+# AdobeColorLib palettes are always indexable by insertion order (an integer
+# key).
+#
+# Version 2 palettes use UTF-16 colour names.
+class ColorLib::Palette::AdobeColorLib
+  include Enumerable
+
+  class << self
+    # Create an AdobeColorLib palette object from the named file.
+    def from_file(filename)
+      File.open(filename, "rb") { |io| ColorLib::Palette::AdobeColorLib.from_io(io) }
+    end
+
+    # Create an AdobeColorLib palette object from the provided IO.
+    def from_io(io)
+      ColorLib::Palette::AdobeColorLib.new(io.read)
+    end
+  end
+
+  # Returns statistics about the nature of the colours loaded.
+  attr_reader :statistics
+  # Contains the "lost" colours in the palette. These colours could not be
+  # properly loaded (e.g., L*a*b* is not supported by ColorLib, so it is
+  # "lost") or are not understood by the algorithms.
+  attr_reader :lost
+
+  # Use this to convert the unsigned word to the signed word, if necessary.
+  UwToSw = proc { |n| (n >= (2 ** 16)) ? n - (2 ** 32) : n } #:nodoc:
+
+  # Create a new AdobeColorLib palette from the palette file as a string.
+  def initialize(palette)
+    @colors     = []
+    @names      = {}
+    @statistics = Hash.new(0)
+    @lost       = []
+    @order      = []
+    @version    = nil
+
+    class << palette
+      def readwords(count = 1)
+        @offset ||= 0
+        raise IndexError if @offset >= self.size
+        val = self[@offset, count * 2]
+        raise IndexError if val.nil? or val.size < (count * 2)
+        val     = val.unpack("n" * count)
+        @offset += count * 2
+        val
+      end
+
+      def readutf16(count = 1)
+        @offset ||= 0
+        raise IndexError if @offset >= self.size
+        val = self[@offset, count * 2]
+        raise IndexError if val.nil? or val.size < (count * 2)
+        @offset += count * 2
+        val
+      end
+    end
+
+    @version, count = palette.readwords 2
+
+    raise "Unknown AdobeColorLib palette version #@version." unless @version.between?(1, 2)
+
+    count.times do
+      space, w, x, y, z = palette.readwords 5
+      name              = nil
+      if @version == 2
+        raise IndexError unless palette.readwords == [0]
+        len  = palette.readwords
+        name = palette.readutf16(len[0] - 1)
+        raise IndexError unless palette.readwords == [0]
+      end
+
+      color = case space
+              when 0 then # RGB
+                @statistics[:rgb] += 1
+
+                ColorLib::RGB.new(w / 256, x / 256, y / 256)
+              when 1 then # HS[BV] -- Convert to RGB
+                @statistics[:hsb] += 1
+
+                h = w / 65535.0
+                s = x / 65535.0
+                v = y / 65535.0
+
+                if defined?(ColorLib::HSB)
+                  ColorLib::HSB.from_fraction(h, s, v)
+                else
+                  @statistics[:converted] += 1
+                  if ColorLib.near_zero_or_less?(s)
+                    ColorLib::RGB.from_fraction(v, v, v)
+                  else
+                    if ColorLib.near_one_or_more?(h)
+                      vh = 0
+                    else
+                      vh = h * 6.0
+                    end
+
+                    vi = vh.floor
+                    v1 = v.to_f * (1 - s.to_f)
+                    v2 = v.to_f * (1 - s.to_f * (vh - vi))
+                    v3 = v.to_f * (1 - s.to_f * (1 - (vh - vi)))
+
+                    case vi
+                    when 0 then
+                      ColorLib::RGB.from_fraction(v, v3, v1)
+                    when 1 then
+                      ColorLib::RGB.from_fraction(v2, v, v1)
+                    when 2 then
+                      ColorLib::RGB.from_fraction(v1, v, v3)
+                    when 3 then
+                      ColorLib::RGB.from_fraction(v1, v2, v)
+                    when 4 then
+                      ColorLib::RGB.from_fraction(v3, v1, v)
+                    else
+                      ColorLib::RGB.from_fraction(v, v1, v2)
+                    end
+                  end
+                end
+              when 2 then # CMYK
+                @statistics[:cmyk] += 1
+                ColorLib::CMYK.from_percent(100 - (w / 655.35),
+                                            100 - (x / 655.35),
+                                            100 - (y / 655.35),
+                                            100 - (z / 655.35))
+              when 7 then # L*a*b*
+                @statistics[:lab] += 1
+
+                l = [w, 10000].min / 100.0
+                a = [[-12800, UwToSw[x]].max, 12700].min / 100.0
+                b = [[-12800, UwToSw[x]].max, 12700].min / 100.0
+
+                if defined? ColorLib::Lab
+                  ColorLib::Lab.new(l, a, b)
+                else
+                  [space, w, x, y, z]
+                end
+              when 8 then # Grayscale
+                @statistics[:gray] += 1
+
+                g = [w, 10000].min / 100.0
+                ColorLib::GrayScale.new(g)
+              when 9 then # Wide CMYK
+                @statistics[:wcmyk] += 1
+
+                c = [w, 10000].min / 100.0
+                m = [x, 10000].min / 100.0
+                y = [y, 10000].min / 100.0
+                k = [z, 10000].min / 100.0
+                ColorLib::CMYK.from_percent(c, m, y, k)
+              else
+                @statistics[space] += 1
+                [space, w, x, y, z]
+              end
+
+      @order << [color, name]
+
+      if color.kind_of? Array
+        @lost << color
+      else
+        @colors << color
+
+        if name
+          @names[name] ||= []
+          @names[name] << color
+        end
+      end
+    end
+  end
+
+  # Provides the colour or colours at the provided selectors.
+  def values_at(*selectors)
+    @colors.values_at(*selectors)
+  end
+
+  # If a Numeric +key+ is provided, the single colour value at that position
+  # will be returned. If a String +key+ is provided, the colour set (an
+  # array) for that colour name will be returned.
+  def [](key)
+    if key.kind_of?(Numeric)
+      @colors[key]
+    else
+      @names[key]
+    end
+  end
+
+  # Loops through each colour.
+  def each
+    @colors.each { |el| yield el }
+  end
+
+  # Loops through each named colour set.
+  def each_name #:yields color_name, color_set:#
+    @names.each { |color_name, color_set| yield color_name, color_set }
+  end
+
+  def size
+    @colors.size
+  end
+
+  attr_reader :version
+
+  def to_aco(version = @version) #:nodoc:
+    res = ""
+
+    res << [version, @order.size].pack("nn")
+
+    @order.each do |cnpair|
+      color, name = *cnpair
+
+      # Note: HSB and CMYK formats are lost by the conversions performed on
+      # import. They are turned into RGB and WCMYK, respectively.
+
+      cstr        = case color
+                    when Array
+                      color
+                    when ColorLib::RGB
+                      r = [(color.red * 256).round, 65535].min
+                      g = [(color.green * 256).round, 65535].min
+                      b = [(color.blue * 256).round, 65535].min
+                      [0, r, g, b, 0]
+                    when ColorLib::GrayScale
+                      g = [(color.gray * 100).round, 10000].min
+                      [8, g, 0, 0, 0]
+                    when ColorLib::CMYK
+                      c = [(color.cyan * 100).round, 10000].min
+                      m = [(color.magenta * 100).round, 10000].min
+                      y = [(color.yellow * 100).round, 10000].min
+                      k = [(color.black * 100).round, 10000].min
+                      [9, c, m, y, k]
+                    end
+      cstr        = cstr.pack("nnnnn")
+
+      nstr = ""
+
+      if version == 2
+        if (name.size / 2 * 2) == name.size # only where s[0] == byte!
+          nstr << [0, (name.size / 2) + 1].pack("nn")
+          nstr << name
+          nstr << [0].pack("n")
+        else
+          nstr << [0, 1, 0].pack("nnn")
+        end
+      end
+
+      res << cstr << nstr
+    end
+
+    res
+  end
+end

data/lib/color_lib/palette/gimp.rb

@@ -0,0 +1,103 @@
+require 'color_lib/palette'
+# A class that can read a GIMP (GNU Image Manipulation Program) palette file
+# and provide a Hash-like interface to the contents. GIMP colour palettes
+# are RGB values only.
+#
+# Because two or more entries in a GIMP palette may have the same name, all
+# named entries are returned as an array.
+#
+#   pal = ColorLib::Palette::Gimp.from_file(my_gimp_palette)
+#   pal[0]          => ColorLib::RGB<...>
+#   pal["white"]    => [ ColorLib::RGB<...> ]
+#   pal["unknown"]  => [ ColorLib::RGB<...>, ColorLib::RGB<...>, ... ]
+#
+# GIMP Palettes are always indexable by insertion order (an integer key).
+class ColorLib::Palette::Gimp
+  include Enumerable
+
+  class << self
+    # Create a GIMP palette object from the named file.
+    def from_file(filename)
+      File.open(filename, "rb") { |io| ColorLib::Palette::Gimp.from_io(io) }
+    end
+
+    # Create a GIMP palette object from the provided IO.
+    def from_io(io)
+      ColorLib::Palette::Gimp.new(io.read)
+    end
+  end
+
+  # Create a new GIMP palette from the palette file as a string.
+  def initialize(palette)
+    @colors = []
+    @names  = {}
+    @valid  = false
+    @name   = "(unnamed)"
+
+    palette.split($/).each do |line|
+      line.chomp!
+      line.gsub!(/\s*#.*\Z/, '')
+
+      next if line.empty?
+
+      if line =~ /\AGIMP Palette\Z/
+        @valid = true
+        next
+      end
+
+      info = /(\w+):\s(.*$)/.match(line)
+      if info
+        @name = info.captures[1] if info.captures[0] =~ /name/i
+        next
+      end
+
+      line.gsub!(/^\s+/, '')
+      data = line.split(/\s+/, 4)
+      name = data.pop.strip
+      data.map! { |el| el.to_i }
+
+      color = ColorLib::RGB.new(*data)
+
+      @colors << color
+      @names[name] ||= []
+      @names[name] << color
+    end
+  end
+
+  # Provides the colour or colours at the provided selectors.
+  def values_at(*selectors)
+    @colors.values_at(*selectors)
+  end
+
+  # If a Numeric +key+ is provided, the single colour value at that position
+  # will be returned. If a String +key+ is provided, the colour set (an
+  # array) for that colour name will be returned.
+  def [](key)
+    if key.kind_of?(Numeric)
+      @colors[key]
+    else
+      @names[key]
+    end
+  end
+
+  # Loops through each colour.
+  def each
+    @colors.each { |el| yield el }
+  end
+
+  # Loops through each named colour set.
+  def each_name #:yields color_name, color_set:#
+    @names.each { |color_name, color_set| yield color_name, color_set }
+  end
+
+  # Returns true if this is believed to be a valid GIMP palette.
+  def valid?
+    @valid
+  end
+
+  def size
+    @colors.size
+  end
+
+  attr_reader :name
+end

data/lib/color_lib/palette/monocontrast.rb

@@ -0,0 +1,169 @@
+require 'color_lib/palette'
+# Generates a monochromatic constrasting colour palette for background and
+# foreground. What does this mean?
+#
+# Monochromatic: A single colour is used to generate the base palette, and
+# this colour is lightened five times and darkened five times to provide
+# eleven distinct colours.
+#
+# Contrasting: The foreground is also generated as a monochromatic colour
+# palette; however, all generated colours are tested to see that they are
+# appropriately contrasting to ensure maximum readability of the foreground
+# against the background.
+class ColorLib::Palette::MonoContrast
+  # Hash of CSS background colour values.
+  # 
+  # This is always 11 values:
+  #
+  # 0::       The starting colour.
+  # +1..+5::  Lighter colours.
+  # -1..-5::  Darker colours.
+  attr_reader :background
+  # Hash of CSS foreground colour values.
+  # 
+  # This is always 11 values:
+  #
+  # 0::       The starting colour.
+  # +1..+5::  Lighter colours.
+  # -1..-5::  Darker colours.
+  attr_reader :foreground
+
+  DEFAULT_MINIMUM_BRIGHTNESS_DIFF = (125.0 / 255.0)
+
+  # The minimum brightness difference between the background and the
+  # foreground, and must be between 0..1. Setting this value will regenerate
+  # the palette based on the base colours. The default value for this is 125
+  # / 255.0. If this value is set to +nil+, it will be restored to the
+  # default.
+  attr_accessor :minimum_brightness_diff
+  remove_method :minimum_brightness_diff=;
+
+  def minimum_brightness_diff=(bd) #:nodoc:
+    if bd.nil?
+      @minimum_brightness_diff = DEFAULT_MINIMUM_BRIGHTNESS_DIFF
+    elsif bd > 1.0
+      @minimum_brightness_diff = 1.0
+    elsif bd < 0.0
+      @minimum_brightness_diff = 0.0
+    else
+      @minimum_brightness_diff = bd
+    end
+
+    regenerate(@background[0], @foreground[0])
+  end
+
+  DEFAULT_MINIMUM_COLOR_DIFF = (500.0 / 255.0)
+
+  # The minimum colour difference between the background and the foreground,
+  # and must be between 0..3. Setting this value will regenerate the palette
+  # based on the base colours. The default value for this is 500 / 255.0.
+  attr_accessor :minimum_color_diff
+  remove_method :minimum_color_diff=;
+
+  def minimum_color_diff=(cd) #:noco:
+    if cd.nil?
+      @minimum_color_diff = DEFAULT_MINIMUM_COLOR_DIFF
+    elsif cd > 3.0
+      @minimum_color_diff = 3.0
+    elsif cd < 0.0
+      @minimum_color_diff = 0.0
+    else
+      @minimum_color_diff = cd
+    end
+    regenerate(@background[0], @foreground[0])
+  end
+
+  # Generate the initial palette.
+  def initialize(background, foreground = nil)
+    @minimum_brightness_diff = DEFAULT_MINIMUM_BRIGHTNESS_DIFF
+    @minimum_color_diff      = DEFAULT_MINIMUM_COLOR_DIFF
+
+    regenerate(background, foreground)
+  end
+
+  # Generate the colour palettes.
+  def regenerate(background, foreground = nil)
+    foreground ||= background
+    background = background.to_rgb
+    foreground = foreground.to_rgb
+
+    @background = {}
+    @foreground = {}
+
+    @background[-5] = background.darken_by(10)
+    @background[-4] = background.darken_by(25)
+    @background[-3] = background.darken_by(50)
+    @background[-2] = background.darken_by(75)
+    @background[-1] = background.darken_by(85)
+    @background[0]  = background
+    @background[+1] = background.lighten_by(85)
+    @background[+2] = background.lighten_by(75)
+    @background[+3] = background.lighten_by(50)
+    @background[+4] = background.lighten_by(25)
+    @background[+5] = background.lighten_by(10)
+
+    @foreground[-5] = calculate_foreground(@background[-5], foreground)
+    @foreground[-4] = calculate_foreground(@background[-4], foreground)
+    @foreground[-3] = calculate_foreground(@background[-3], foreground)
+    @foreground[-2] = calculate_foreground(@background[-2], foreground)
+    @foreground[-1] = calculate_foreground(@background[-1], foreground)
+    @foreground[0]  = calculate_foreground(@background[0], foreground)
+    @foreground[+1] = calculate_foreground(@background[+1], foreground)
+    @foreground[+2] = calculate_foreground(@background[+2], foreground)
+    @foreground[+3] = calculate_foreground(@background[+3], foreground)
+    @foreground[+4] = calculate_foreground(@background[+4], foreground)
+    @foreground[+5] = calculate_foreground(@background[+5], foreground)
+  end
+
+  # Given a background colour and a foreground colour, modifies the
+  # foreground colour so that it will have enough contrast to be seen
+  # against the background colour.
+  #
+  # Uses #mininum_brightness_diff and #minimum_color_diff.
+  def calculate_foreground(background, foreground)
+    nfg = nil
+    # Loop through brighter and darker versions of the foreground color. The
+    # numbers here represent the amount of foreground color to mix with
+    # black and white.
+    [100, 75, 50, 25, 0].each do |percent|
+      dfg = foreground.darken_by(percent)
+      lfg = foreground.lighten_by(percent)
+
+      dbd = brightness_diff(background, dfg)
+      lbd = brightness_diff(background, lfg)
+
+      if lbd > dbd
+        nfg = lfg
+        nbd = lbd
+      else
+        nfg = dfg
+        nbd = dbd
+      end
+
+      ncd = color_diff(background, nfg)
+
+      break if nbd >= @minimum_brightness_diff and ncd >= @minimum_color_diff
+    end
+    nfg
+  end
+
+  # Returns the absolute difference between the brightness levels of two
+  # colours. This will be a decimal value between 0 and 1. W3C accessibility
+  # guidelines for colour contrast[http://www.w3.org/TR/AERT#color-contrast]
+  # suggest that this value be at least approximately 0.49 (125 / 255.0) for
+  # proper contrast.
+  def brightness_diff(c1, c2)
+    (c1.brightness - c2.brightness).abs
+  end
+
+  # Returns the contrast between to colours, a decimal value between 0 and
+  # 3. W3C accessibility guidelines for colour
+  # contrast[http://www.w3.org/TR/AERT#color-contrast] suggest that this
+  # value be at least approximately 1.96 (500 / 255.0) for proper contrast.
+  def color_diff(c1, c2)
+    r = (c1.r - c2.r).abs
+    g = (c1.g - c2.g).abs
+    b = (c1.b - c2.b).abs
+    r + g + b
+  end
+end