atome 0.5.7.0.3 → 0.3191

data/lib/atome/utilities/color_helper/color/grayscale.rb

@@ -1,197 +0,0 @@
-# A colour object representing shades of grey. Used primarily in PDF
-# document creation.
-class Color::GrayScale
-  include Color
-
-  # The format of a DeviceGrey colour for PDF. In color-tools 2.0 this will
-  # be removed from this package and added back as a modification by the
-  # PDF::Writer package.
-  PDF_FORMAT_STR  = "%.3f %s"
-
-  class << self
-    # Creates a greyscale colour object from fractional values 0..1.
-    #
-    #   Color::GreyScale.from_fraction(0.5)
-    def from_fraction(g = 0, &block)
-      new(g, 1.0, &block)
-    end
-
-    # Creates a greyscale colour object from percentages 0..100.
-    #
-    #   Color::GrayScale.from_percent(50)
-    def from_percent(g = 0, &block)
-      new(g, &block)
-    end
-  end
-
-  # Creates a greyscale colour object from percentages 0..100.
-  #
-  #   Color::GrayScale.new(50)
-  def initialize(g = 0, radix = 100.0, &block) # :yields self:
-    @g = Color.normalize(g / radix)
-    block.call if block
-  end
-
-  # Coerces the other Color object to grayscale.
-  def coerce(other)
-    other.to_grayscale
-  end
-
-  # Present the colour as a DeviceGrey fill colour string for PDF. This will
-  # be removed from the default package in color-tools 2.0.
-  def pdf_fill
-    PDF_FORMAT_STR % [ @g, "g" ]
-  end
-
-  # Present the colour as a DeviceGrey stroke colour string for PDF. This
-  # will be removed from the default package in color-tools 2.0.
-  def pdf_stroke
-    PDF_FORMAT_STR % [ @g, "G" ]
-  end
-
-  def to_255
-    [(@g * 255).round, 255].min
-  end
-  private :to_255
-
-  # Present the colour as an HTML/CSS colour string.
-  def html
-    gs = "%02x" % to_255
-    "##{gs * 3}"
-  end
-
-  # Present the colour as an RGB HTML/CSS colour string (e.g., "rgb(0%, 50%,
-  # 100%)").
-  def css_rgb
-    "rgb(%3.2f%%, %3.2f%%, %3.2f%%)" % [ gray, gray, gray ]
-  end
-
-  # Present the colour as an RGBA (with alpha) HTML/CSS colour string (e.g.,
-  # "rgb(0%, 50%, 100%, 1)").
-  def css_rgba(alpha = 1)
-    "rgba(%3.2f%%, %3.2f%%, %3.2f%%, %1.2f)" % [ gray, gray, gray, alpha ]
-  end
-
-  # Present the colour as an HSL HTML/CSS colour string (e.g., "hsl(180,
-  # 25%, 35%)"). Note that this will perform a #to_hsl operation.
-  def css_hsl
-    to_hsl.css_hsl
-  end
-
-  # Present the colour as an HSLA (with alpha) HTML/CSS colour string (e.g.,
-  # "hsla(180, 25%, 35%, 1)"). Note that this will perform a #to_hsl
-  # operation.
-  def css_hsla
-    to_hsl.css_hsla
-  end
-
-  # Convert the greyscale colour to CMYK.
-  def to_cmyk
-    k = 1.0 - @g.to_f
-    Color::CMYK.from_fraction(0, 0, 0, k)
-  end
-
-  # Convert the greyscale colour to RGB.
-  def to_rgb(ignored = true)
-    Color::RGB.from_fraction(g, g, g)
-  end
-
-  # Reflexive conversion.
-  def to_grayscale
-    self
-  end
-  alias to_greyscale to_grayscale
-
-  # Lightens the greyscale colour by the stated percent.
-  def lighten_by(percent)
-    g = [@g + (@g * (percent / 100.0)), 1.0].min
-    Color::GrayScale.from_fraction(g)
-  end
-
-  # Darken the greyscale colour by the stated percent.
-  def darken_by(percent)
-    g = [@g - (@g * (percent / 100.0)), 0.0].max
-    Color::GrayScale.from_fraction(g)
-  end
-
-  # Returns the YIQ (NTSC) colour encoding of the greyscale value. This is
-  # an approximation, as the values for I and Q are calculated by treating
-  # the greyscale value as an RGB value. The Y (intensity or brightness)
-  # value is the same as the greyscale value.
-  def to_yiq
-    y = @g
-    i = (@g * 0.596) + (@g * -0.275) + (@g * -0.321)
-    q = (@g * 0.212) + (@g * -0.523) + (@g *  0.311)
-    Color::YIQ.from_fraction(y, i, q)
-  end
-
-  # Returns the HSL colour encoding of the greyscale value.
-  def to_hsl
-    Color::HSL.from_fraction(0, 0, @g)
-  end
-
-  # Returns the brightness value for this greyscale value; this is the
-  # greyscale value itself.
-  def brightness
-    @g
-  end
-
-  # Returns the grayscale value as a percentage of white (100% gray is
-  # white).
-  def gray
-    @g * 100.0
-  end
-  alias grey gray
-  # Returns the grayscale value as a fractional value of white in the range
-  # 0.0 .. 1.0.
-  def g
-    @g
-  end
-  # Sets the grayscale value as a percentage of white.
-  def gray=(gg)
-    @g = Color.normalize(gg / 100.0)
-  end
-  alias grey= gray= ;
-  # Returns the grayscale value as a fractional value of white in the range
-  # 0.0 .. 1.0.
-  def g=(gg)
-    @g = Color.normalize(gg)
-  end
-
-  # Adds another colour to the current colour. The other colour will be
-  # converted to grayscale before addition. This conversion depends upon a
-  # #to_grayscale method on the other colour.
-  #
-  # The addition is done using the grayscale accessor methods to ensure a
-  # valid colour in the result.
-  def +(other)
-    self.class.from_fraction(g + other.to_grayscale.g)
-  end
-
-  # Subtracts another colour to the current colour. The other colour will be
-  # converted to grayscale before subtraction. This conversion depends upon
-  # a #to_grayscale method on the other colour.
-  #
-  # The subtraction is done using the grayscale accessor methods to ensure a
-  # valid colour in the result.
-  def -(other)
-    self + (-other)
-  end
-
-  def inspect
-    "Gray [%.2f%%]" % [ gray ]
-  end
-
-  def to_a
-    [ g ]
-  end
-
-  def -@
-    gs = self.dup
-    gs.instance_variable_set(:@g, -g)
-    gs
-  end
-end
-
-# A synonym for Color::GrayScale.
-Color::GreyScale = Color::GrayScale

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

@@ -1,240 +0,0 @@
-# -*- 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/utilities/color_helper/color/palette/adobecolor.rb

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