atome 0.4.7.0 → 0.5.1.1

data/lib/atome/helpers/color_helper/color/hsl.rb

@@ -0,0 +1,240 @@
+# -*- ruby encoding: utf-8 -*-
+
+# 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
+  include Color
+
+  class << self
+    # Creates an HSL colour object from fractional values 0..1.
+    def from_fraction(h = 0.0, s = 0.0, l = 0.0, &block)
+      new(h, s, l, 1.0, 1.0, &block)
+    end
+  end
+
+  # Coerces the other Color object into HSL.
+  def coerce(other)
+    other.to_hsl
+  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, radix1 = 360.0, radix2 = 100.0, &block) # :yields self:
+    @h = Color.normalize(h / radix1)
+    @s = Color.normalize(s / radix2)
+    @l = Color.normalize(l / radix2)
+    block.call if block
+  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(alpha = 1)
+    to_rgb.css_rgba(alpha)
+  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 from HSL to RGB. As with all colour conversions, this is
+  # approximate at best. The code here is adapted from fvd and van Dam,
+  # originally found at [1] (implemented similarly at [2]).
+  #
+  # This simplifies the calculations with the following assumptions:
+  # - Luminance values <= 0 always translate to Color::RGB::Black.
+  # - Luminance values >= 1 always translate to Color::RGB::White.
+  # - Saturation values <= 0 always translate to a shade of gray using
+  #   luminance as a percentage of gray.
+  #
+  # [1] http://bobpowell.net/RGBHSB.aspx
+  # [2] http://support.microsoft.com/kb/29240
+  def to_rgb(*)
+    if Color.near_zero_or_less?(l)
+      Color::RGB::Black
+    elsif Color.near_one_or_more?(l)
+      Color::RGB::White
+    elsif Color.near_zero?(s)
+      Color::RGB.from_grayscale_fraction(l)
+    else
+      # Only needed for Ruby 1.8. For Ruby 1.9+, we can do:
+      # Color::RGB.new(*compute_fvd_rgb, 1.0)
+      Color::RGB.new(*(compute_fvd_rgb + [ 1.0 ]))
+    end
+  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)
+    v = to_a.zip(coerce(color).to_a).map { |(x, y)|
+      ((y - x) * mix_percent) + x
+    }
+    self.class.from_fraction(*v)
+  end
+
+  def to_a
+    [ h, s, l ]
+  end
+
+  private
+
+  # This algorithm calculates based on a mixture of the saturation and
+  # luminance, and then takes the RGB values from the hue + 1/3, hue, and
+  # hue - 1/3 positions in a circular representation of colour divided into
+  # four parts (confusing, I know, but it's the way that it works). See
+  # #hue_to_rgb for more information.
+  def compute_fvd_rgb
+    t1, t2 = fvd_mix_sat_lum
+    [ h + (1 / 3.0), h, h - (1 / 3.0) ].map { |v|
+      hue_to_rgb(rotate_hue(v), t1, t2)
+    }
+  end
+
+  # Mix saturation and luminance for use in hue_to_rgb. The base value is
+  # different depending on whether luminance is <= 50% or > 50%.
+  def fvd_mix_sat_lum
+    t = if Color.near_zero_or_less?(l - 0.5)
+             l * (1.0 + s.to_f)
+           else
+             l + s - (l * s.to_f)
+           end
+    [ 2.0 * l - t, t ]
+  end
+
+  # In HSL, hues are referenced as degrees in a colour circle. The flow
+  # itself is endless; therefore, we can rotate around. The only thing our
+  # implementation restricts is that you should not be > 1.0.
+  def rotate_hue(h)
+    h += 1.0 if Color.near_zero_or_less?(h)
+    h -= 1.0 if Color.near_one_or_more?(h)
+    h
+  end
+
+  # We calculate the interaction of the saturation/luminance mix (calculated
+  # earlier) based on the position of the hue in the circular colour space
+  # divided into quadrants. Our hue range is [0, 1), not [0, 360º).
+  #
+  # - The first quadrant covers the first 60º [0, 60º].
+  # - The second quadrant covers the next 120º (60º, 180º].
+  # - The third quadrant covers the next 60º (180º, 240º].
+  # - The fourth quadrant covers the final 120º (240º, 360º).
+  def hue_to_rgb(h, t1, t2)
+    if Color.near_zero_or_less?((6.0 * h) - 1.0)
+      t1 + ((t2 - t1) * h * 6.0)
+    elsif Color.near_zero_or_less?((2.0 * h) - 1.0)
+      t2
+    elsif Color.near_zero_or_less?((3.0 * h) - 2.0)
+      t1 + (t2 - t1) * ((2 / 3.0) - h) * 6.0
+    else
+      t1
+    end
+  end
+end

data/lib/atome/helpers/color_helper/color/palette/adobecolor.rb

@@ -0,0 +1,260 @@
+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/atome/helpers/color_helper/color/palette/gimp.rb

@@ -0,0 +1,104 @@
+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