class RGB

# File lib/redgreenblue/misc.rb, line 34
def self.assemble(*a)
  v = a.flatten
  RGB.new(v[0].red, v[1].green, v[2].blue)
end

# File lib/redgreenblue/int.rb, line 9
def self.at(number)
  n = number.to_i
  if (0..16777215) === n
    rgb(
      ( n & 0xff0000 ) >> 16,
      ( n & 0x00ff00 ) >>  8,
      ( n & 0x0000ff )
    )
  else
    raise ArgumentError, "Argument '#{number}' not in range 0..16777215"
  end
end

# File lib/redgreenblue/inspect.rb, line 44
def self.base_style
  if styles.include? ENV['REDGREENBLUE_STYLE']
    ENV['REDGREENBLUE_STYLE']
  else
    if ENV['COLORTERM'] == 'truecolor'
      'simple'
    else
      'default'
    end
  end
end

# File lib/redgreenblue/bgr24bit.rb, line 14
def self.bgr24(bgr)
  c = self.new
  c.bgr24 = bgr
  c
end

# File lib/redgreenblue/lazy.rb, line 15
def black
  new(0,0,0)
end

# File lib/redgreenblue/lazy.rb, line 40
def blue
  new(0,0,1)
end

# File lib/redgreenblue/lazy.rb, line 65
def centre
  grey
end

# File lib/redgreenblue/lazy.rb, line 60
def corners
  [ black, red, yellow, green, cyan, blue, magenta, white ]
end

# File lib/redgreenblue/web.rb, line 32
def css(selector=nil)
  @@css ||= load_gpl file: ( File.join File.dirname(__FILE__), 'palettes', 'css.gpl' ), freeze: true
  case selector
    when NilClass
      @@css
    when String
      n = selector.downcase
      @@css.select { |c| c.name == n }.first
    when Regexp
      r = Regexp.new selector.source, Regexp::IGNORECASE
      @@css.select { |c| c.name =~ r }
    when Integer
      @@css[selector]
    when self
      @@css.select { |c| c == selector }
    else
      raise ArgumentError, 'Unsupported selector'
  end
end

# File lib/redgreenblue/lazy.rb, line 50
def cyan
  new(0,1,1)
end

# File lib/redgreenblue/24bit.rb, line 68
def self.each_24bit_color
  range = 0..255
  range.each do |r|
    range.each do |g|
      range.each do |b|
        yield self.rgb(r,g,b)
      end
    end
  end
  range.size ** 3
end

# File lib/redgreenblue/gpl.rb, line 13
def gpl(line)
  if line.chomp.match( /^\s*(?<r>\d{1,3})\s+(?<g>\d{1,3})\s+(?<b>\d{1,3})(\s+(?<name>.*))?/ )
    color = RGB.rgb $~[:r].to_i, $~[:g].to_i, $~[:b].to_i
    color.name = $~[:name] if $~[:name]
    color
  else
    nil
  end
end

# File lib/redgreenblue/gpl.rb, line 74
def gpl_header(name=nil, columns: nil)
  "GIMP Palette\n" +
  ( name    ? "Name: #{name}\n"       : '' ) +
  ( columns ? "Columns: #{columns}\n" : '' )
end

# File lib/redgreenblue/lazy.rb, line 35
def green
  new(0,1,0)
end

# File lib/redgreenblue/lazy.rb, line 22
def grey(lightness=0.5)
  new(lightness, lightness, lightness)
end

# File lib/redgreenblue/hex.rb, line 32
def self.hex(hex_string)
  if rgb = RGB.hex_to_rgb(hex_string)
    self.rgb rgb
  else
    raise ArgumentError, "'#{hex_string}' is not a usable hexadecimal string"
  end
end

# File lib/redgreenblue/hex.rb, line 43
def self.hex_shorthand(hex_string)
  hex_string.sub( /^(#?)(\h)\2(\h)\3(\h)\4$/, '\1\2\3\4' )
end

# File lib/redgreenblue/hex.rb, line 51
def self.hex_to_rgb(hex_string)
  if hex_string =~ /^(#?)(\h\h)(\h\h)(\h\h)$/
    [$2, $3, $4].map { |h| h.to_i(16) }
  elsif hex_string =~ /^(#?)(\h)(\h)(\h)$/
    [$2, $3, $4].map { |h| (h*2).to_i(16) }
  else
    nil
  end
end

# File lib/redgreenblue/hsl.rb, line 13
def hsl(*a)
  new hsl_to_values(*a)
end

# File lib/redgreenblue/hsl.rb, line 20
def hsl_to_values(*a)
  hsm_to_values(:hsl, a)
end

# File lib/redgreenblue/hsv.rb, line 13
def hsv(*a)
  new hsv_to_values(*a)
end

# File lib/redgreenblue/hsv.rb, line 20
def hsv_to_values(*a)
  hsm_to_values(:hsv, a)
end

# File lib/redgreenblue/gpl.rb, line 38
def load_gpl(source=nil, file: nil, url: nil, compact: true, freeze: false)

  if ! source
    if file
      source = File.open file
    elsif url
      require 'open-uri'
      source = URI.open url
    end
  end

  if source.respond_to? :each_line
    list = source.each_line.map { |line| RGB.gpl(line) }

    if compact
      list.compact!
    end

    if freeze
      list.freeze
      list.each &:freeze
    end

    list
  else
    raise ArgumentError, 'Not a valid source'
  end
end

# File lib/redgreenblue/lazy.rb, line 55
def magenta
  new(1,0,1)
end

# File lib/redgreenblue/base.rb, line 3
def initialize(*a)
  self.values = a.any? ? a : [ 0.5, 0.5, 0.5 ]
end

# File lib/redgreenblue/os/mac.rb, line 16
def self.pick(default_color=RGB.new)
  result = RGB.mac_choose(default_color)
  if result
    RGB.rrggbb result
  else
    nil
  end
end

# File lib/redgreenblue/random.rb, line 21
def self.rand
  new(Kernel::rand, Kernel::rand, Kernel::rand)
end

# File lib/redgreenblue/lazy.rb, line 30
def red
  new(1,0,0)
end

# File lib/redgreenblue/24bit.rb, line 48
def self.rgb(*rgb)
  c = self.new
  c.rgb = rgb
  c
end

# File lib/redgreenblue/rgb565.rb, line 19
def self.rgb565(rgb565_string)
  c = self.new
  c.rgb565 = rgb565_string
  c
end

# File lib/redgreenblue/48bit.rb, line 48
def self.rrggbb(*rrggbb)
  c = self.new
  c.rrggbb = rrggbb
  c
end

# File lib/redgreenblue/inspect.rb, line 57
def self.style
  @@style ||= base_style
end

# File lib/redgreenblue/inspect.rb, line 69
def self.style=(s)
  @@style = styles.grep( /^#{s.to_s.downcase}/ ).first || style
end

# File lib/redgreenblue/inspect.rb, line 62
def self.styles
  ( self.instance_methods + self.private_instance_methods ).grep( /^_inspect_(.*)/ ) { $1 }.sort
end

# File lib/redgreenblue/version.rb, line 7
def self.version
  VERSION
end

# File lib/redgreenblue/lazy.rb, line 10
def white
  new(1,1,1)
end

# File lib/redgreenblue/lazy.rb, line 45
def yellow
  new(1,1,0)
end

# File lib/redgreenblue/hsx_shared.rb, line 14
def hsm_to_values(type, *a)
  raise NotImplementedError unless [:hsl, :hsv].include? type

  hue, saturation, magnitude = a.flatten

  if ( saturation == 0 ) or ( ! hue )
    return Array.new(3) { magnitude }
  end

  hue = hue.modulo 360

  chroma = case type
    when :hsl
      ( 1 - ( 2 * magnitude - 1 ).abs ) * saturation
    when :hsv
      magnitude * saturation
  end

  values = [
    chroma,
    ( 1 - ( ( hue / 60.0 ).modulo(2) - 1 ).abs ) * chroma,
    0
  ]

  values = case type
    when :hsl
      values.map { |v| ( v + magnitude - chroma / 2.0 ).round(9) }
    when :hsv
      values.map { |v| ( v + magnitude - chroma       ).round(9) }
  end

  # order values according to hue sextant
  [ [0,1,2], [1,0,2], [2,0,1], [2,1,0], [1,2,0], [0,2,1] ][hue.div 60].map { |i| values[i]}
end

# File lib/redgreenblue/os/mac.rb, line 35
  def self.mac_choose(default_color)

    app = case ENV['TERM_PROGRAM']
      when /iTerm\.app/
        'iTerm'
      else
        'Terminal'
      end

    script = <<~ENDSCRIPT
      tell application "#{app}"
        try
          return choose color default color #{default_color.applescript}
        on error
          return ""
        end try
      end tell
    ENDSCRIPT

    result = `osascript -e '#{script}'`.chomp

    if result.empty?
      nil
    else
      (result.split( /,\w*/ )).map { |s| s.to_i }
    end

  end

# File lib/redgreenblue/base.rb, line 65
def ==(other)
  ( self.class == other.class ) && ( self.values == other.values )
end

# File lib/redgreenblue/misc.rb, line 16
def achromatic?
  values.min == values.max
end

# File lib/redgreenblue/mac.rb, line 4
def applescript
  "{%i, %i, %i}" % rrggbb
end

# File lib/redgreenblue/24bit.rb, line 16
def b
  (blue  * 255).round
end

# File lib/redgreenblue/24bit.rb, line 31
def b=(n)
  self.blue  = n / 255.0
end

# File lib/redgreenblue/48bit.rb, line 16
def bb
  (blue  * 65535).round
end

# File lib/redgreenblue/48bit.rb, line 31
def bb=(n)
  self.blue  = n / 65535.0
end

# File lib/redgreenblue/bgr24bit.rb, line 4
def bgr24
  [b, g, r].pack('C3')
end

# File lib/redgreenblue/bgr24bit.rb, line 9
def bgr24=(bgr_string)
  self.b, self.g, self.r = bgr_string.unpack('C3')
end

# File lib/redgreenblue/mix.rb, line 34
def blacken(portion=0.5, *portions)
  if (portion.class != Array) and portions.none?
    mix(RGB.black, portion)
  else
    ( [portion].flatten + portions ).map { |p| mix(RGB.black, p) }
  end
end

# File lib/redgreenblue/mix.rb, line 29
def blacken!(portion=0.5)
  mix!(RGB.black, portion)
end

# File lib/redgreenblue/base.rb, line 25
def blue
  @blue
end

# File lib/redgreenblue/base.rb, line 46
def blue=(value)
  @blue = limit(value)
end

# File lib/redgreenblue/cie_1976.rb, line 4
def cie_lab(round: true)
  cie_lab_luv(round: round, type: :lab)
end

# File lib/redgreenblue/cie_1976.rb, line 13
def cie_lch_ab
  cie_lch_ab_uv(type: :lab)
end

# File lib/redgreenblue/cie_1976.rb, line 27
def cie_lch_uv
  cie_lch_ab_uv(type: :luv)
end

# File lib/redgreenblue/cie_1976.rb, line 18
def cie_luv(round: true)
  cie_lab_luv(round: round, type: :luv)
end

# File lib/redgreenblue/cie_1931.rb, line 45
def cie_xy
  cie_xyy[0..1]
end

# File lib/redgreenblue/cie_1931.rb, line 30
def cie_xyy
  x, y, z = cie_xyz(round: false)

  [

    x / ( x + y + z ),
    y / ( x + y + z ),
    y

  ].map { |v| v.round(8) }
end

# File lib/redgreenblue/cie_1931.rb, line 10
def cie_xyz(round: true)
  r, g, b = linear_values

  [

    r * 0.4124_5643_9090 + g * 0.3575_7607_7644 + b * 0.1804_3748_3266,
    r * 0.2126_7285_1406 + g * 0.7151_5215_5288 + b * 0.0721_7499_3307,
    r * 0.0193_3389_5582 + g * 0.1191_9202_5881 + b * 0.9503_0407_8536

  ].map { |v| round ? v.round(8) : v }
end

# File lib/redgreenblue/base.rb, line 10
def color_space
  'sRGB'
end

# File lib/redgreenblue/misc.rb, line 29
def components
  [ RGB.new(red,0,0), RGB.new(0,green,0), RGB.new(0,0,blue) ]
end

# File lib/redgreenblue/web.rb, line 61
def css_hex
  "##{hex true}"
end

# File lib/redgreenblue/web.rb, line 68
def css_names
  RGB.css(self).map &:name
end

# File lib/redgreenblue/cie_1976.rb, line 36
def delta_e_cie_1976(another)
  l , a , b  =         cie_lab(round: false)
  l2, a2, b2 = another.cie_lab(round: false)

  Math.sqrt( (l - l2) ** 2 + (a - a2) ** 2 + (b - b2) ** 2 ).round(8)
end

# File lib/redgreenblue/misc.rb, line 44
def distance(another)
  (
    ( (another.red   - red  ) ** 2) +
    ( (another.green - green) ** 2) +
    ( (another.blue  - blue ) ** 2)
  ) ** (1/2.0)
end

# File lib/redgreenblue/24bit.rb, line 11
def g
  (green * 255).round
end

# File lib/redgreenblue/24bit.rb, line 26
def g=(n)
  self.green = n / 255.0
end

# File lib/redgreenblue/48bit.rb, line 11
def gg
  (green * 65535).round
end

# File lib/redgreenblue/48bit.rb, line 26
def gg=(n)
  self.green = n / 65535.0
end

# File lib/redgreenblue/gif.rb, line 7
def gif_pixel
  "GIF89a\1\0\1\0\x90\0\0".b +
  rgb.pack('C3') +
  "\0\0\0,\0\0\0\0\1\0\1\0\0\x02\x02\x04\1\0;".b
end

# File lib/redgreenblue/gif.rb, line 14
def gif_pixel_write(file_path)
  File.binwrite(file_path, gif_pixel)
end

# File lib/redgreenblue/gpl.rb, line 89
def gpl(gpl_name=name)
  ( "%3d %3d %3d" % rgb ) +
  ( gpl_name.to_s.size != 0 ? "\t#{gpl_name}" : '' )
end

# File lib/redgreenblue/base.rb, line 20
def green
  @green
end

# File lib/redgreenblue/base.rb, line 39
def green=(value)
  @green = limit(value)
end

# File lib/redgreenblue/hex.rb, line 6
def hex(shorthand=false)
  if shorthand
    RGB.hex_shorthand hex6
  else
    hex6
  end
end

# File lib/redgreenblue/hex.rb, line 17
def hex=(hex_string)
  if rgb = RGB.hex_to_rgb(hex_string)
    self.rgb = rgb
  else
    raise ArgumentError, "'#{hex_string}' is not a usable hexadecimal string"
  end
end

# File lib/redgreenblue/hsl.rb, line 33
def hsl
  hsl_hsv_c[0]
end

# File lib/redgreenblue/hsl.rb, line 53
def hsl=(*a)
  self.values = RGB.hsl_to_values(*a)
end

# File lib/redgreenblue/hsl.rb, line 38
def hsl_h
  hsl[0]
end

# File lib/redgreenblue/hsl.rb, line 61
def hsl_h=(degrees)
  self.hsl = hsl.fill(degrees,0,1)
end

# File lib/redgreenblue/hsl.rb, line 48
def hsl_l
  hsl[2]
end

# File lib/redgreenblue/hsl.rb, line 77
def hsl_l=(value)
  self.hsl = hsl.fill(value  ,2,1)
end

# File lib/redgreenblue/hsl.rb, line 88
def hsl_rotate(a_degrees, *b_degrees)
  if a_degrees.class != Array and b_degrees.none?
    RGB.hsl zip_add(hsl, [a_degrees, 0, 0])
  else
    ( [a_degrees] + b_degrees ).flatten.map { |degrees| RGB.hsl zip_add(hsl, [degrees, 0, 0]) }
  end
end

# File lib/redgreenblue/hsl.rb, line 82
def hsl_rotate!(degrees)
  self.hsl = zip_add(hsl, [degrees, 0, 0])
  self
end

# File lib/redgreenblue/hsl.rb, line 43
def hsl_s
  hsl[1]
end

# File lib/redgreenblue/hsl.rb, line 69
def hsl_s=(value)
  self.hsl = hsl.fill(value  ,1,1)
end

# File lib/redgreenblue/hsv.rb, line 33
def hsv
  hsl_hsv_c[1]
end

# File lib/redgreenblue/hsv.rb, line 53
def hsv=(*a)
  self.values = RGB.hsv_to_values(*a)
end

# File lib/redgreenblue/hsv.rb, line 38
def hsv_h
  hsv[0]
end

# File lib/redgreenblue/hsv.rb, line 61
def hsv_h=(degrees)
  self.hsv = hsv.fill(degrees,0,1)
end

# File lib/redgreenblue/hsv.rb, line 88
def hsv_rotate(a_degrees, *b_degrees)
  if a_degrees.class != Array and b_degrees.none?
    RGB.hsv zip_add(hsv, [a_degrees, 0, 0])
  else
    ( [a_degrees] + b_degrees ).flatten.map { |degrees| RGB.hsv zip_add(hsv, [degrees, 0, 0]) }
  end
end

# File lib/redgreenblue/hsv.rb, line 82
def hsv_rotate!(degrees)
  self.hsv = zip_add(hsv, [degrees, 0, 0])
  self
end

# File lib/redgreenblue/hsv.rb, line 43
def hsv_s
  hsv[1]
end

# File lib/redgreenblue/hsv.rb, line 69
def hsv_s=(value)
  self.hsv = hsv.fill(value  ,1,1)
end

# File lib/redgreenblue/hsv.rb, line 48
def hsv_v
  hsv[2]
end

# File lib/redgreenblue/hsv.rb, line 77
def hsv_v=(value)
  self.hsv = hsv.fill(value  ,2,1)
end

# File lib/redgreenblue/hwb.rb, line 10
def hwb
  [ hsv_h, cwk[1,2] ].flatten
end

# File lib/redgreenblue/inspect.rb, line 34
def inspect
  send "_inspect_#{self.class.style}"
end

# File lib/redgreenblue/misc.rb, line 10
def invert
  dup.invert!
end

# File lib/redgreenblue/misc.rb, line 4
def invert!
  self.values = values.map { |v| 1 - v }
  self
end

# File lib/redgreenblue/gamma.rb, line 9
def linear_values
  if color_space == 'sRGB'
    values.map { |v|
      if v <= 0.04045
        v / 12.92
      else
        ( ( v + 0.055 ) / 1.055 ) ** 2.4
      end
    }
  else
    raise "can not compute gamma for color space '#{color_space}'"
  end
end

# File lib/redgreenblue/gamma.rb, line 30
def linear_values=(*a)
  if color_space == 'sRGB'
    self.values = a.flatten.map { |v|
      if v <= 0.0031308
        v * 12.92
      else
        1.055 * ( v ** ( 1/2.4 ) ) - 0.055
      end
    }.map { |v| v.round(9) }
  else
    raise "can not compute gamma for color space '#{color_space}'"
  end
end

# File lib/redgreenblue/match.rb, line 17
def match_de76(others)
  others.map { |c| [ c, de76(c) ] }.sort_by { |a| a[1] }
end

# File lib/redgreenblue/match.rb, line 8
def match_distance(others)
  others.map { |c| [ c, distance(c) ] }.sort_by { |a| a[1] }
end

# File lib/redgreenblue/mix.rb, line 10
def mix(another,portion=0.5)
  RGB.new mix_values(another.values, portion)
end

# File lib/redgreenblue/mix.rb, line 4
def mix!(another,portion=0.5)
  self.values = mix_values(another.values, portion)
  self
end

# File lib/redgreenblue/name.rb, line 4
def name
  defined?(@name) ? @name : nil
end

# File lib/redgreenblue/name.rb, line 9
def name=(text)
  @name = ( text.to_s.size != 0 ) ? text.to_s : nil
end

# File lib/redgreenblue/ostwald.rb, line 15
def ostwald_color
  white_portion = values.min
  color_portion = values.max - white_portion

  if color_portion == 0
    nil
  else
    RGB.new( values.map { |v| ( ( v - white_portion ) / color_portion ).round(6) } )
  end
end

# File lib/redgreenblue/ostwald.rb, line 35
def ostwald_cwk(round: true)
  [
    color_portion = values.max - values.min,
    white_portion = values.min,
    1 - color_portion - white_portion
  ].map { |v| round ? v.round(8) : v }
end

# File lib/redgreenblue/misc.rb, line 24
def permutation
  values.permutation.to_a.uniq.map { |v| RGB.new v }
end

# File lib/redgreenblue/os/mac.rb, line 5
def pick
  result = RGB.mac_choose(self)
  if result
    self.rrggbb = result
  end
end

# File lib/redgreenblue/24bit.rb, line 6
def r
  (red   * 255).round
end

# File lib/redgreenblue/24bit.rb, line 21
def r=(n)
  self.red   = n / 255.0
end

# File lib/redgreenblue/random.rb, line 15
def randomize!
  self.values = Kernel::rand, Kernel::rand, Kernel::rand
  self
end

# File lib/redgreenblue/base.rb, line 15
def red
  @red
end

# File lib/redgreenblue/base.rb, line 32
def red=(value)
  @red = limit(value)
end

# File lib/redgreenblue/24bit.rb, line 38
def rgb
  [r,g,b]
end

# File lib/redgreenblue/rgb565.rb, line 4
def rgb565
  [((r >> 3) << 11) + ((g >> 2) << 5) + (b >> 3)].pack 'S<'
end

# File lib/redgreenblue/rgb565.rb, line 11
def rgb565=(rgb565_string)
  v = ( rgb565_string.unpack "S<" )[0]
  self.r = ( ( v & 0xf800 ) >> 11 ) << 3
  self.g = ( ( v & 0x07e0 ) >>  5 ) << 2
  self.b = ( ( v & 0x001f )       ) << 3
end

# File lib/redgreenblue/24bit.rb, line 43
def rgb=(*rgb)
  self.r, self.g, self.b = rgb.flatten
end

# File lib/redgreenblue/48bit.rb, line 6
def rr
  (red   * 65535).round
end

# File lib/redgreenblue/48bit.rb, line 21
def rr=(n)
  self.red   = n / 65535.0
end

# File lib/redgreenblue/48bit.rb, line 38
def rrggbb
  [rr,gg,bb]
end

# File lib/redgreenblue/48bit.rb, line 43
def rrggbb=(*rrggbb)
  self.rr, self.gg, self.bb = rrggbb.flatten
end

# File lib/redgreenblue/random.rb, line 10
def shuffle
  RGB.new values.shuffle
end

# File lib/redgreenblue/random.rb, line 4
def shuffle!
  self.values = values.shuffle
  self
end

# File lib/redgreenblue/24bit.rb, line 61
def snap
  RGB.rgb rgb
end

# File lib/redgreenblue/24bit.rb, line 55
def snap!
  self.rgb = rgb
  self
end

# File lib/redgreenblue/mix.rb, line 46
def steps(another,step_count=1,include_begin=false)
  # origin (self, optional)
  ( include_begin ? [self.dup] : [] ) +
  # ...plus intermediate colors
  (1..step_count-1).map { |c| mix(another, c.to_f/step_count) } +
  # ...plus destination color
  [another.dup]
end

# File lib/redgreenblue/terminal.rb, line 15
def terminal_background
  "\e[48;2;%d;%d;%dm" % rgb
end

# File lib/redgreenblue/terminal.rb, line 9
def terminal_foreground
  "\e[38;2;%d;%d;%dm" % rgb
end

# File lib/redgreenblue/base.rb, line 71
def to_h
  ([:red, :green, :blue].zip values).sort_by {
    |k,v| [-v,[:red, :green, :blue].index(k)]
  }.to_h
end

# File lib/redgreenblue/int.rb, line 4
def to_i
  ( r << 16 ) + ( g << 8 ) + b
end

# File lib/redgreenblue/opt/philipshue.rb, line 26
def to_philips_hue_api_hsb_arguments(black_off=true)
  my_hsb = hsb

  # Black means 'off'
  if black_off and ( my_hsb[2] == 0 )
    { 'on'  => false }

  else
    {

      # On/Off state of the light
      'on'  => true,

      # Brightness 1..254
      # Note: a brightness of 1 will not switch the light off
      'bri' => (  my_hsb[2]        * 253 + 1     ).round,

      # Hue 0..65535
      'hue' => (( my_hsb[0] || 0 ) * 65535 / 360 ).round,

      # Saturation 0..254
      'sat' => (  my_hsb[1]        * 254         ).round

    }

  end
end

# File lib/redgreenblue/inspect.rb, line 39
def to_s
  _inspect_default
end

# File lib/redgreenblue/base.rb, line 51
def values
  [ red, green, blue ]
end

# File lib/redgreenblue/base.rb, line 60
def values=(*a)
  self.red, self.green, self.blue = a.flatten
end

# File lib/redgreenblue/view.rb, line 4
def view
  puts _inspect_view
end

# File lib/redgreenblue/web.rb, line 98
def wcag20_contrast_ratio(another, round: true)
  luminances = [
    wcag20_luminance(round: false),
    another.wcag20_luminance(round: false)
  ].sort.reverse

  contrast_ratio = ( luminances[0] + 0.05 ) / ( luminances[1] + 0.05 )

  round ? contrast_ratio.round(8) : contrast_ratio
end

# File lib/redgreenblue/web.rb, line 78
def wcag20_luminance(round: true)
  if color_space == 'sRGB'
    values.map { |v|
      if v <= 0.03928
        v / 12.92
      else
        ( ( v + 0.055 ) / 1.055 ) ** 2.4
      end
    }.zip( [0.2126, 0.7152, 0.0722] ).map { |c,f|
      c * f
    }.inject(:+).instance_eval { |v| round ? v.round(8) : v }
  else
    raise "can not calculate luminance for color space '#{color_space}'"
  end
end

# File lib/redgreenblue/mix.rb, line 20
def whiten(portion=0.5, *portions)
  if (portion.class != Array) and portions.none?
    mix(RGB.white, portion)
  else
    ( [portion].flatten + portions ).map { |p| mix(RGB.white, p) }
  end
end

# File lib/redgreenblue/mix.rb, line 15
def whiten!(portion=0.5)
  mix!(RGB.white, portion)
end

# File lib/redgreenblue/inspect.rb, line 5
def _inspect_default(prefix='RGB')
  "#{prefix} #{_inspect_hex} (red=%1.5f green=%1.5f blue=%1.5f)" % [red, green, blue] + ( name ? ' ' + name : '' )
end

# File lib/redgreenblue/inspect.rb, line 9
def _inspect_hex
  (self == snap ? '#' : '~') + hex
end

# File lib/redgreenblue/inspect.rb, line 25
def _inspect_name
  _inspect_swatch + ( name ? ' ' + name : '' )
end

# File lib/redgreenblue/inspect.rb, line 17
def _inspect_short
  "#{_inspect_swatch} #{_inspect_hex}"
end

# File lib/redgreenblue/inspect.rb, line 21
def _inspect_simple
  _inspect_default _inspect_swatch
end

# File lib/redgreenblue/inspect.rb, line 13
def _inspect_swatch
  terminal_background + "   \e[0m"
end

# File lib/redgreenblue/view.rb, line 12
def _inspect_view
  o = []
  o << 3.times.map { terminal_background + "      \e[0m "}
  o << [ "#{_inspect_hex} ", '%-7.7s ' % color_space, '        ' ]

  o << components.map { |c| c.terminal_background + "  \e[0m " }
  o << %w(R: G: B:)
  o << values.map { |v| '%1.5f ' % v }
  o << rgb.map { |v| '%3d ' % v }

  o << %w(H: S: L:)
  o << hsl.map { |v| v ? ('%7.3f ' % v) : '  -     ' }
  o << %w(H: S: B:)
  o << hsb.map { |v| v ? ('%7.3f ' % v) : '  -     ' }

  o << 3.times.map { (ostwald_color ? ostwald_color.terminal_background + "  \e[0m " : '   ') }
  o << %w(C: W: K:)
  o << ostwald_cwk.map { |v| '%1.3f ' % v }

  o.transpose.map(&:join).join("\n")
end

# File lib/redgreenblue/cie_1976.rb, line 58
def cie_lab_luv(round: true, type: :lab)
  x , y , z  =           cie_xyz(round: false)
  xr, yr, zr = RGB.white.cie_xyz(round: false)

  f = [ x / xr, y / yr, z / zr ].map { |v|
    if v > ( 216.0 / 24389 )
      Math.cbrt v
    else
      ( 24389.0 / 27 * v + 16 ) / 116.0
    end
  }

  if type == :luv
    [
      l = 116 * f[1] - 16,
      13 * l * ( ( 4 * x ) / ( x + 15 * y + 3 * z ) - ( 4 * xr ) / ( xr + 15 * yr + 3 * zr ) ),
      13 * l * ( ( 9 * y ) / ( x + 15 * y + 3 * z ) - ( 9 * yr ) / ( xr + 15 * yr + 3 * zr ) )
    ]
  else
    [
      116 *  f[1] - 16,
      500 * (f[0] - f[1]),
      200 * (f[1] - f[2])
    ]
  end.map { |v| v.nan? ? 0.0 : ( round ? v.round(8) : v ) }
end

# File lib/redgreenblue/cie_1976.rb, line 91
def cie_lch_ab_uv(type: :lab)
  if type == :luv
    l, v1, v2 = cie_luv(round: false)
  else
    l, v1, v2 = cie_lab(round: false)
  end

  [
    l.round(8),
    c = Math.hypot(v1, v2).round(8),
    c == 0 ? nil : ( Math.atan2(v2, v1) * 180.0 / Math::PI ).modulo(360).round(8)
  ]
end

# File lib/redgreenblue/hex.rb, line 63
def hex6
  '%02x%02x%02x' % [ r, g, b ]
end

# File lib/redgreenblue/hsx_shared.rb, line 60
def hsl_hsv_c
  sorted_hash = to_h
  min, max = sorted_hash.values.values_at(2,0)

  chroma = max - min

  hue =
    if chroma == 0
      nil
    else
      ( case sorted_hash.keys.first
        when :red
          60 * ( ( ( green - blue  ) / chroma ).modulo 6 )
        when :green
          60 * ( (   blue  - red   ) / chroma + 2 )
        when :blue
          60 * ( (   red   - green ) / chroma + 4 )
        end
      ).round(6)
    end

  lightness = ( min + max ) / 2.0

  saturation_hsl =
    chroma == 0 ? 0.0 : ( chroma / ( 1 - (2 * lightness - 1).abs ) ).round(9)

  value = max

  saturation_hsv =
    value == 0 ? 0.0 : chroma / value

  [ [hue, saturation_hsl, lightness], [hue, saturation_hsv, value], chroma ]
end

# File lib/redgreenblue/base.rb, line 80
def limit(n)
  n <= 0 ? 0.0 : n >= 1 ? 1.0 : n
end

# File lib/redgreenblue/mix.rb, line 57
def mix_values(some_values, portion)
  raise(ArgumentError, "Portion '#{portion}' not in range (0..1)") unless (0..1).include? portion
  [
    ( red   * (1 - portion) ) + ( some_values[0] * portion ),
    ( green * (1 - portion) ) + ( some_values[1] * portion ),
    ( blue  * (1 - portion) ) + ( some_values[2] * portion )
  ]
end

# File lib/redgreenblue/math.rb, line 5
def zip_add(a,b)
  a.zip(b).map { |ab| ( ab[0] || 0 ) + ab[1] }
end