rmthemegen 0.0.23 → 0.0.25

data/lib/rmthemegen/color/color/hsl.rb

@@ -0,0 +1,221 @@
+#--
+# Color
+# Colour management with Ruby
+# http://rubyforge.org/projects/color
+#   Version 1.4.1
+#
+# Licensed under a MIT-style licence. See Licence.txt in the main
+# distribution for full licensing information.
+#
+# Copyright (c) 2005 - 2010 Austin Ziegler and Matt Lyon
+#++
+
+# An HSL colour object. Internally, the hue (#h), saturation (#s), and
+# luminosity/lightness (#l) values are dealt with as fractional values in
+# the range 0..1.
+class Color::HSL
+  class << self
+    # Creates an HSL colour object from fractional values 0..1.
+    def from_fraction(h = 0.0, s = 0.0, l = 0.0)
+      colour = Color::HSL.new
+      colour.h = h
+      colour.s = s
+      colour.l = l
+      colour
+    end
+  end
+
+  # Compares the other colour to this one. The other colour will be
+  # converted to HSL before comparison, so the comparison between a HSL
+  # colour and a non-HSL colour will be approximate and based on the other
+  # colour's #to_hsl conversion. If there is no #to_hsl conversion, this
+  # will raise an exception. This will report that two HSL values are
+  # equivalent if all component values are within Color::COLOR_TOLERANCE of
+  # each other.
+  def ==(other)
+    other = other.to_hsl
+    other.kind_of?(Color::HSL) and
+    ((@h - other.h).abs <= Color::COLOR_TOLERANCE) and
+    ((@s - other.s).abs <= Color::COLOR_TOLERANCE) and
+    ((@l - other.l).abs <= Color::COLOR_TOLERANCE)
+  end
+
+  # Creates an HSL colour object from the standard values of degrees and
+  # percentages (e.g., 145 deg, 30%, 50%).
+  def initialize(h = 0, s = 0, l = 0)
+    @h = h / 360.0
+    @s = s / 100.0
+    @l = l / 100.0
+  end
+
+  # Present the colour as an HTML/CSS colour string.
+  def html
+    to_rgb.html
+  end
+
+  # Present the colour as an RGB HTML/CSS colour string (e.g., "rgb(0%, 50%,
+  # 100%)"). Note that this will perform a #to_rgb operation using the
+  # default conversion formula.
+  def css_rgb
+    to_rgb.css_rgb
+  end
+
+  # Present the colour as an RGBA (with alpha) HTML/CSS colour string (e.g.,
+  # "rgb(0%, 50%, 100%, 1)"). Note that this will perform a #to_rgb
+  # operation using the default conversion formula.
+  def css_rgba
+    to_rgb.css_rgba
+  end
+
+  # Present the colour as an HSL HTML/CSS colour string (e.g., "hsl(180,
+  # 25%, 35%)").
+  def css_hsl
+    "hsl(%3.2f, %3.2f%%, %3.2f%%)" % [ hue, saturation, luminosity ]
+  end
+
+  # Present the colour as an HSLA (with alpha) HTML/CSS colour string (e.g.,
+  # "hsla(180, 25%, 35%, 1)").
+  def css_hsla
+    "hsla(%3.2f, %3.2f%%, %3.2f%%, %3.2f)" % [ hue, saturation, luminosity, 1 ]
+  end
+
+  # Converting to HSL as adapted from Foley and Van-Dam from
+  # http://www.bobpowell.net/RGBHSB.htm.
+  #
+  # NOTE:
+  # * If the colour's luminosity is near zero, the colour is always black.
+  # * If the colour's luminosity is near one, the colour is always white.
+  # * If the colour's saturation is near zero, the colour is always a shade
+  #   of grey and is based only on the luminosity of the colour.
+  #
+  def to_rgb(ignored = nil)
+    return Color::RGB.new if Color.near_zero_or_less?(@l)
+    return Color::RGB.new(0xff, 0xff, 0xff) if Color.near_one_or_more?(@l)
+    return Color::RGB.from_fraction(@l, @l, @l) if Color.near_zero?(@s)
+
+    # Is the value less than 0.5?
+    if Color.near_zero_or_less?(@l - 0.5)
+      tmp2 = @l * (1.0 + @s.to_f)
+    else
+      tmp2 = @l + @s - (@l * @s.to_f)
+    end
+    tmp1 = 2.0 * @l - tmp2
+
+    tmp3  = [ @h + (1.0 / 3.0), @h, @h - (1.0 / 3.0) ]
+
+    rgb = tmp3.map { |hue|
+      hue += 1.0 if Color.near_zero_or_less?(hue)
+      hue -= 1.0 if Color.near_one_or_more?(hue)
+
+      if Color.near_zero_or_less?((6.0 * hue) - 1.0)
+        tmp1 + ((tmp2 - tmp1) * hue * 6.0)
+      elsif Color.near_zero_or_less?((2.0 * hue) - 1.0)
+        tmp2
+      elsif Color.near_zero_or_less?((3.0 * hue) - 2.0)
+        tmp1 + (tmp2 - tmp1) * ((2 / 3.0) - hue) * 6.0
+      else
+        tmp1
+      end
+    }
+
+     Color::RGB.from_fraction(*rgb)
+  end
+
+  # Converts to RGB then YIQ.
+  def to_yiq
+    to_rgb.to_yiq
+  end
+
+  # Converts to RGB then CMYK.
+  def to_cmyk
+    to_rgb.to_cmyk
+  end
+
+  # Returns the luminosity (#l) of the colour.
+  def brightness
+    @l
+  end
+  def to_greyscale
+    Color::GrayScale.from_fraction(@l)
+  end
+  alias to_grayscale to_greyscale
+
+  # Returns the hue of the colour in degrees.
+  def hue
+    @h * 360.0
+  end
+  # Returns the hue of the colour in the range 0.0 .. 1.0.
+  def h
+    @h
+  end
+  # Sets the hue of the colour in degrees. Colour is perceived as a wheel,
+  # so values should be set properly even with negative degree values.
+  def hue=(hh)
+    hh = hh / 360.0
+
+    hh += 1.0 if hh < 0.0
+    hh -= 1.0 if hh > 1.0
+
+    @h = Color.normalize(hh)
+  end
+  # Sets the hue of the colour in the range 0.0 .. 1.0.
+  def h=(hh)
+    @h = Color.normalize(hh)
+  end
+  # Returns the percentage of saturation of the colour.
+  def saturation
+    @s * 100.0
+  end
+  # Returns the saturation of the colour in the range 0.0 .. 1.0.
+  def s
+    @s
+  end
+  # Sets the percentage of saturation of the colour.
+  def saturation=(ss)
+    @s = Color.normalize(ss / 100.0)
+  end
+  # Sets the saturation of the colour in the ragne 0.0 .. 1.0.
+  def s=(ss)
+    @s = Color.normalize(ss)
+  end
+
+  # Returns the percentage of luminosity of the colour.
+  def luminosity
+    @l * 100.0
+  end
+  alias lightness luminosity
+  # Returns the luminosity of the colour in the range 0.0 .. 1.0.
+  def l
+    @l
+  end
+  # Sets the percentage of luminosity of the colour.
+  def luminosity=(ll)
+    @l = Color.normalize(ll / 100.0)
+  end
+  alias lightness= luminosity= ;
+  # Sets the luminosity of the colour in the ragne 0.0 .. 1.0.
+  def l=(ll)
+    @l = Color.normalize(ll)
+  end
+
+  def to_hsl
+    self
+  end
+
+  def inspect
+    "HSL [%.2f deg, %.2f%%, %.2f%%]" % [ hue, saturation, luminosity ]
+  end
+
+  # Mix the mask colour (which will be converted to an HSL colour) with the
+  # current colour at the stated mix percentage as a decimal value.
+  #
+  # NOTE::  This differs from Color::RGB#mix_with.
+  def mix_with(color, mix_percent = 0.5)
+    color   = color.to_hsl
+    _h = ((color.h - self.h) * mix_percent) + self.h
+    _s = ((color.s - self.s) * mix_percent) + self.s
+    _l = ((color.l - self.l) * mix_percent) + self.l
+
+    self.class.from_fraction(_h, _s, _l)
+  end
+end

data/lib/rmthemegen/color/color/palette/adobecolor.rb

@@ -0,0 +1,272 @@
+#--
+# Color
+# Colour management with Ruby
+# http://rubyforge.org/projects/color
+#   Version 1.4.1
+#
+# Licensed under a MIT-style licence. See Licence.txt in the main
+# distribution for full licensing information.
+#
+# Copyright (c) 2005 - 2010 Austin Ziegler and Matt Lyon
+#++
+
+require 'color/palette'
+
+# A class that can read an Adobe Color 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 Color files have named colours; all named entries are
+# returned as an array.
+#
+#   pal = Color::Palette::AdobeColor.from_file(my_aco_palette)
+#   pal[0]          => Color::RGB<...>
+#   pal["white"]    => [ Color::RGB<...> ]
+#   pal["unknown"]  => [ Color::RGB<...>, Color::RGB<...>, ... ]
+#
+# AdobeColor palettes are always indexable by insertion order (an integer
+# key).
+#
+# Version 2 palettes use UTF-16 colour names.
+class Color::Palette::AdobeColor
+  include Enumerable
+
+  class << self
+    # Create an AdobeColor palette object from the named file.
+    def from_file(filename)
+      File.open(filename, "rb") { |io| Color::Palette::AdobeColor.from_io(io) }
+    end
+
+    # Create an AdobeColor palette object from the provided IO.
+    def from_io(io)
+      Color::Palette::AdobeColor.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 Color, 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 AdobeColor 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 AdobeColor 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
+
+                Color::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?(Color::HSB)
+                  Color::HSB.from_fraction(h, s, v)
+                else
+                  @statistics[:converted] += 1
+                  if Color.near_zero_or_less?(s)
+                    Color::RGB.from_fraction(v, v, v)
+                  else
+                    if Color.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 Color::RGB.from_fraction(v, v3, v1)
+                    when 1 then Color::RGB.from_fraction(v2, v, v1)
+                    when 2 then Color::RGB.from_fraction(v1, v, v3)
+                    when 3 then Color::RGB.from_fraction(v1, v2, v)
+                    when 4 then Color::RGB.from_fraction(v3, v1, v)
+                    else Color::RGB.from_fraction(v, v1, v2)
+                    end
+                  end
+                end
+              when 2 then # CMYK
+                @statistics[:cmyk] += 1
+                Color::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? Color::Lab
+                  Color::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
+                Color::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
+                Color::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 Color::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 Color::GrayScale
+               g = [(color.gray * 100).round, 10000].min
+               [ 8, g, 0, 0, 0 ]
+             when Color::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/rmthemegen/color/color/palette/gimp.rb

@@ -0,0 +1,116 @@
+#--
+# Color
+# Colour management with Ruby
+# http://rubyforge.org/projects/color
+#   Version 1.4.1
+#
+# Licensed under a MIT-style licence. See Licence.txt in the main
+# distribution for full licensing information.
+#
+# Copyright (c) 2005 - 2010 Austin Ziegler and Matt Lyon
+#++
+
+require 'color/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 = Color::Palette::Gimp.from_file(my_gimp_palette)
+#   pal[0]          => Color::RGB<...>
+#   pal["white"]    => [ Color::RGB<...> ]
+#   pal["unknown"]  => [ Color::RGB<...>, Color::RGB<...>, ... ]
+#
+# GIMP Palettes are always indexable by insertion order (an integer key).
+class Color::Palette::Gimp
+  include Enumerable
+
+  class << self
+    # Create a GIMP palette object from the named file.
+    def from_file(filename)
+      File.open(filename, "rb") { |io| Color::Palette::Gimp.from_io(io) }
+    end
+
+    # Create a GIMP palette object from the provided IO.
+    def from_io(io)
+      Color::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 = Color::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