Module: ChunkyPNG::Color

Extended by:
Color
Included in:
Color
Defined in:
lib/chunky_png/color.rb

Overview

The Color module defines methods for handling colors. Within the ChunkyPNG library, the concepts of pixels and colors are both used, and they are both represented by a Integer.

Pixels/colors are represented in RGBA components. Each of the four components is stored with a depth of 8 bits (maximum value = 255 = MAX). Together, these components are stored in a 4-byte Integer.

A color will always be represented using these 4 components in memory. When the image is encoded, a more suitable representation can be used (e.g. rgb, grayscale, palette-based), for which several conversion methods are provided in this module.

Constant Summary

MAX =
0xff
MAX_EUCLIDEAN_DISTANCE_RGBA =

Could be simplified as MAX * 2, but this format mirrors the math in #euclidean_distance_rgba

Math.sqrt(MAX**2 * 4)
PREDEFINED_COLORS =
{
  :aliceblue            => 0xf0f8ff00,
  :antiquewhite         => 0xfaebd700,
  :aqua                 => 0x00ffff00,
  :aquamarine           => 0x7fffd400,
  :azure                => 0xf0ffff00,
  :beige                => 0xf5f5dc00,
  :bisque               => 0xffe4c400,
  :black                => 0x00000000,
  :blanchedalmond       => 0xffebcd00,
  :blue                 => 0x0000ff00,
  :blueviolet           => 0x8a2be200,
  :brown                => 0xa52a2a00,
  :burlywood            => 0xdeb88700,
  :cadetblue            => 0x5f9ea000,
  :chartreuse           => 0x7fff0000,
  :chocolate            => 0xd2691e00,
  :coral                => 0xff7f5000,
  :cornflowerblue       => 0x6495ed00,
  :cornsilk             => 0xfff8dc00,
  :crimson              => 0xdc143c00,
  :cyan                 => 0x00ffff00,
  :darkblue             => 0x00008b00,
  :darkcyan             => 0x008b8b00,
  :darkgoldenrod        => 0xb8860b00,
  :darkgray             => 0xa9a9a900,
  :darkgrey             => 0xa9a9a900,
  :darkgreen            => 0x00640000,
  :darkkhaki            => 0xbdb76b00,
  :darkmagenta          => 0x8b008b00,
  :darkolivegreen       => 0x556b2f00,
  :darkorange           => 0xff8c0000,
  :darkorchid           => 0x9932cc00,
  :darkred              => 0x8b000000,
  :darksalmon           => 0xe9967a00,
  :darkseagreen         => 0x8fbc8f00,
  :darkslateblue        => 0x483d8b00,
  :darkslategray        => 0x2f4f4f00,
  :darkslategrey        => 0x2f4f4f00,
  :darkturquoise        => 0x00ced100,
  :darkviolet           => 0x9400d300,
  :deeppink             => 0xff149300,
  :deepskyblue          => 0x00bfff00,
  :dimgray              => 0x69696900,
  :dimgrey              => 0x69696900,
  :dodgerblue           => 0x1e90ff00,
  :firebrick            => 0xb2222200,
  :floralwhite          => 0xfffaf000,
  :forestgreen          => 0x228b2200,
  :fuchsia              => 0xff00ff00,
  :gainsboro            => 0xdcdcdc00,
  :ghostwhite           => 0xf8f8ff00,
  :gold                 => 0xffd70000,
  :goldenrod            => 0xdaa52000,
  :gray                 => 0x80808000,
  :grey                 => 0x80808000,
  :green                => 0x00800000,
  :greenyellow          => 0xadff2f00,
  :honeydew             => 0xf0fff000,
  :hotpink              => 0xff69b400,
  :indianred            => 0xcd5c5c00,
  :indigo               => 0x4b008200,
  :ivory                => 0xfffff000,
  :khaki                => 0xf0e68c00,
  :lavender             => 0xe6e6fa00,
  :lavenderblush        => 0xfff0f500,
  :lawngreen            => 0x7cfc0000,
  :lemonchiffon         => 0xfffacd00,
  :lightblue            => 0xadd8e600,
  :lightcoral           => 0xf0808000,
  :lightcyan            => 0xe0ffff00,
  :lightgoldenrodyellow => 0xfafad200,
  :lightgray            => 0xd3d3d300,
  :lightgrey            => 0xd3d3d300,
  :lightgreen           => 0x90ee9000,
  :lightpink            => 0xffb6c100,
  :lightsalmon          => 0xffa07a00,
  :lightseagreen        => 0x20b2aa00,
  :lightskyblue         => 0x87cefa00,
  :lightslategray       => 0x77889900,
  :lightslategrey       => 0x77889900,
  :lightsteelblue       => 0xb0c4de00,
  :lightyellow          => 0xffffe000,
  :lime                 => 0x00ff0000,
  :limegreen            => 0x32cd3200,
  :linen                => 0xfaf0e600,
  :magenta              => 0xff00ff00,
  :maroon               => 0x80000000,
  :mediumaquamarine     => 0x66cdaa00,
  :mediumblue           => 0x0000cd00,
  :mediumorchid         => 0xba55d300,
  :mediumpurple         => 0x9370d800,
  :mediumseagreen       => 0x3cb37100,
  :mediumslateblue      => 0x7b68ee00,
  :mediumspringgreen    => 0x00fa9a00,
  :mediumturquoise      => 0x48d1cc00,
  :mediumvioletred      => 0xc7158500,
  :midnightblue         => 0x19197000,
  :mintcream            => 0xf5fffa00,
  :mistyrose            => 0xffe4e100,
  :moccasin             => 0xffe4b500,
  :navajowhite          => 0xffdead00,
  :navy                 => 0x00008000,
  :oldlace              => 0xfdf5e600,
  :olive                => 0x80800000,
  :olivedrab            => 0x6b8e2300,
  :orange               => 0xffa50000,
  :orangered            => 0xff450000,
  :orchid               => 0xda70d600,
  :palegoldenrod        => 0xeee8aa00,
  :palegreen            => 0x98fb9800,
  :paleturquoise        => 0xafeeee00,
  :palevioletred        => 0xd8709300,
  :papayawhip           => 0xffefd500,
  :peachpuff            => 0xffdab900,
  :peru                 => 0xcd853f00,
  :pink                 => 0xffc0cb00,
  :plum                 => 0xdda0dd00,
  :powderblue           => 0xb0e0e600,
  :purple               => 0x80008000,
  :red                  => 0xff000000,
  :rosybrown            => 0xbc8f8f00,
  :royalblue            => 0x4169e100,
  :saddlebrown          => 0x8b451300,
  :salmon               => 0xfa807200,
  :sandybrown           => 0xf4a46000,
  :seagreen             => 0x2e8b5700,
  :seashell             => 0xfff5ee00,
  :sienna               => 0xa0522d00,
  :silver               => 0xc0c0c000,
  :skyblue              => 0x87ceeb00,
  :slateblue            => 0x6a5acd00,
  :slategray            => 0x70809000,
  :slategrey            => 0x70809000,
  :snow                 => 0xfffafa00,
  :springgreen          => 0x00ff7f00,
  :steelblue            => 0x4682b400,
  :tan                  => 0xd2b48c00,
  :teal                 => 0x00808000,
  :thistle              => 0xd8bfd800,
  :tomato               => 0xff634700,
  :turquoise            => 0x40e0d000,
  :violet               => 0xee82ee00,
  :wheat                => 0xf5deb300,
  :white                => 0xffffff00,
  :whitesmoke           => 0xf5f5f500,
  :yellow               => 0xffff0000,
  :yellowgreen          => 0x9acd3200
}
BLACK =
rgb(  0,   0,   0)
WHITE =
rgb(255, 255, 255)
TRANSPARENT =
rgba(0, 0, 0, 0)

Instance Method Summary (collapse)

Instance Method Details

- (Integer) a(value)

Returns the alpha channel value for the color value.



211
212
213
# File 'lib/chunky_png/color.rb', line 211

def a(value)
  value & 0x000000ff
end

- (Boolean) alpha_decomposable?(color, mask, bg, tolerance = 1)

Checks whether an alpha channel value can successfully be composed given the resulting color, the mask color and a background color, all of which should be opaque.

See Also:



415
416
417
418
419
420
# File 'lib/chunky_png/color.rb', line 415

def alpha_decomposable?(color, mask, bg, tolerance = 1)
  components = decompose_alpha_components(color, mask, bg)
  sum = components.inject(0) { |a,b| a + b }
  max = components.max * 3
  components.max <= 255 && components.min >= 0 && (sum + tolerance * 3) >= max
end

- (Integer) b(value)

Returns the blue-component from the color value.



203
204
205
# File 'lib/chunky_png/color.rb', line 203

def b(value)
  (value & 0x0000ff00) >> 8
end

- (Integer) blend(fg, bg)

Blends the foreground and background color by taking the average of the components.



318
319
320
# File 'lib/chunky_png/color.rb', line 318

def blend(fg, bg)
  (fg + bg) >> 1
end

- (Integer) compose_precise(fg, bg)

Composes two colors with an alpha channel using floating point math.

This method uses more precise floating point math, but this precision is lost when the result is converted back to an integer. Because it is slower than the version based on integer math, that version is preferred.

See Also:



295
296
297
298
299
300
301
302
303
304
305
306
307
308
# File 'lib/chunky_png/color.rb', line 295

def compose_precise(fg, bg)
  return fg if opaque?(fg) || fully_transparent?(bg)
  return bg if fully_transparent?(fg)

  fg_a  = a(fg).to_f / MAX
  bg_a  = a(bg).to_f / MAX
  a_com = (1.0 - fg_a) * bg_a

  new_r = (fg_a * r(fg) + a_com * r(bg)).round
  new_g = (fg_a * g(fg) + a_com * g(bg)).round
  new_b = (fg_a * b(fg) + a_com * b(bg)).round
  new_a = ((fg_a + a_com) * MAX).round
  rgba(new_r, new_g, new_b, new_a)
end

- (Integer) compose_quick(fg, bg) Also known as: compose

Composes two colors with an alpha channel using integer math.

This version is faster than the version based on floating point math, so this compositing function is used by default.

See Also:



273
274
275
276
277
278
279
280
281
282
283
# File 'lib/chunky_png/color.rb', line 273

def compose_quick(fg, bg)
  return fg if opaque?(fg) || fully_transparent?(bg)
  return bg if fully_transparent?(fg)

  a_com = int8_mult(0xff - a(fg), a(bg))
  new_r = int8_mult(a(fg), r(fg)) + int8_mult(a_com, r(bg))
  new_g = int8_mult(a(fg), g(fg)) + int8_mult(a_com, g(bg))
  new_b = int8_mult(a(fg), b(fg)) + int8_mult(a_com, b(bg))
  new_a = a(fg) + a_com
  rgba(new_r, new_g, new_b, new_a)
end

- (Integer) decompose_alpha(color, mask, bg)

Decomposes the alpha channel value given the resulting color, the mask color and a background color, all of which should be opaque.

Make sure to call #alpha_decomposable? first to see if the alpha channel value can successfully decomposed with a given tolerance, otherwise the return value of this method is undefined.



436
437
438
439
# File 'lib/chunky_png/color.rb', line 436

def decompose_alpha(color, mask, bg)
  components = decompose_alpha_components(color, mask, bg)
  (components.inject(0) { |a,b| a + b } / 3.0).round
end

- (Integer) decompose_alpha_component(channel, color, mask, bg)

Decomposes an alpha channel for either the r, g or b color channel.



449
450
451
452
453
454
455
456
457
# File 'lib/chunky_png/color.rb', line 449

def decompose_alpha_component(channel, color, mask, bg)
  cc, mc, bc = send(channel, color), send(channel, mask), send(channel, bg)

  return 0x00 if bc == cc
  return 0xff if bc == mc
  return 0xff if cc == mc

  (((bc - cc).to_f / (bc - mc).to_f) * MAX).round
end

- (Array<Integer>) decompose_alpha_components(color, mask, bg)

Decomposes the alpha channels for the r, g and b color channel.



466
467
468
469
470
471
472
# File 'lib/chunky_png/color.rb', line 466

def decompose_alpha_components(color, mask, bg)
  [
    decompose_alpha_component(:r, color, mask, bg),
    decompose_alpha_component(:g, color, mask, bg),
    decompose_alpha_component(:b, color, mask, bg)
  ]
end

- (Integer) decompose_color(color, mask, bg, tolerance = 1)

Decomposes a color, given a color, a mask color and a background color. The returned color will be a variant of the mask color, with the alpha channel set to the best fitting value. This basically is the reverse operation if alpha composition.

If the color cannot be decomposed, this method will return the fully transparent variant of the mask color.



394
395
396
397
398
399
400
# File 'lib/chunky_png/color.rb', line 394

def decompose_color(color, mask, bg, tolerance = 1)
  if alpha_decomposable?(color, mask, bg, tolerance)
    mask & 0xffffff00 | decompose_alpha(color, mask, bg)
  else
    mask & 0xffffff00
  end
end

- (Float) euclidean_distance_rgba(pixel_after, pixel_before)

Compute the Euclidean distance between 2 colors in RGBA

This method simply takes the Euclidean distance between the RGBA channels of 2 colors, which gives us a measure of how different the two colors are.

Although it would be more perceptually accurate to calculate a proper Delta E in Lab colorspace, this method should serve many use-cases while avoiding the overhead of converting RGBA to Lab.



546
547
548
549
550
551
552
553
# File 'lib/chunky_png/color.rb', line 546

def euclidean_distance_rgba(pixel_after, pixel_before)
  Math.sqrt(
    (r(pixel_after) - r(pixel_before))**2 +
    (g(pixel_after) - g(pixel_before))**2 +
    (b(pixel_after) - b(pixel_before))**2 +
    (a(pixel_after) - a(pixel_before))**2
  )
end

- (Integer) fade(color, factor)

Lowers the intensity of a color, by lowering its alpha by a given factor.



373
374
375
376
# File 'lib/chunky_png/color.rb', line 373

def fade(color, factor)
  new_alpha = int8_mult(a(color), factor)
  (color & 0xffffff00) | new_alpha
end

- (Integer) from_hex(hex_value, opacity = nil)

Creates a color by converting it from a string in hex notation.

It supports colors with (#rrggbbaa) or without (#rrggbb) alpha channel as well as the 3-digit short format (#rgb) for those without. Color strings may include the prefix “0x” or “#”.

Raises:

  • (ArgumentError)

    if the value given is not a hex color notation.



166
167
168
169
170
171
172
173
174
175
176
177
# File 'lib/chunky_png/color.rb', line 166

def from_hex(hex_value, opacity = nil)
  base_color = case hex_value
               when HEX3_COLOR_REGEXP
                 $1.gsub(/([0-9a-f])/i, '\1\1').hex << 8
               when HEX6_COLOR_REGEXP
                 $1.hex << 8
               else
                 raise ArgumentError, "Not a valid hex color notation: #{hex_value.inspect}!"
               end
  opacity  ||= $2 ? $2.hex : 0xff
  base_color | opacity
end

- (Integer) from_rgb_stream(stream, pos = 0)

Creates a color by unpacking an rgb triple from a string.



140
141
142
# File 'lib/chunky_png/color.rb', line 140

def from_rgb_stream(stream, pos = 0)
  rgb(*stream.unpack("@#{pos}C3"))
end

- (Integer) from_rgba_stream(stream, pos = 0)

Creates a color by unpacking an rgba triple from a string



150
151
152
# File 'lib/chunky_png/color.rb', line 150

def from_rgba_stream(stream, pos = 0)
  rgba(*stream.unpack("@#{pos}C4"))
end

- (true, false) fully_transparent?(value)

Returns true if this color is fully transparent.



242
243
244
# File 'lib/chunky_png/color.rb', line 242

def fully_transparent?(value)
  a(value) == 0x00000000
end

- (Integer) g(value)

Returns the green-component from the color value.



195
196
197
# File 'lib/chunky_png/color.rb', line 195

def g(value)
  (value & 0x00ff0000) >> 16
end

- (Integer) grayscale(teint)

Creates a new color using a grayscale teint.



117
118
119
# File 'lib/chunky_png/color.rb', line 117

def grayscale(teint)
  teint << 24 | teint << 16 | teint << 8 | 0xff
end

- (true, false) grayscale?(value)

Returns true if this color is fully transparent.



234
235
236
# File 'lib/chunky_png/color.rb', line 234

def grayscale?(value)
  r(value) == b(value) && b(value) == g(value)
end

- (Integer) grayscale_alpha(teint, a)

Creates a new color using a grayscale teint and alpha value.



126
127
128
# File 'lib/chunky_png/color.rb', line 126

def grayscale_alpha(teint, a)
  teint << 24 | teint << 16 | teint << 8 | a
end

- (Integer) grayscale_teint(color)

Calculates the grayscale teint of an RGB color.



350
351
352
# File 'lib/chunky_png/color.rb', line 350

def grayscale_teint(color)
  (r(color) * 0.3 + g(color) * 0.59 + b(color) * 0.11).round
end

- (Integer) html_color(color_name, opacity = nil)

Gets a color value based on a HTML color name.

The color name is flexible. E.g. 'yellowgreen', 'Yellow green', 'YellowGreen', 'YELLOW_GREEN' and :yellow_green will all return the same color value.

You can include a opacity level in the color name (e.g. 'red @ 0.5') or give an explicit opacity value as second argument. If no opacity value is given, the color will be fully opaque.

Raises:



731
732
733
734
735
736
737
738
# File 'lib/chunky_png/color.rb', line 731

def html_color(color_name, opacity = nil)
  if color_name.to_s =~ HTML_COLOR_REGEXP
    opacity ||= $2 ? ($2.to_f * 255.0).round : 0xff
    base_color_name = $1.gsub(/[^a-z]+/i, '').downcase.to_sym
    return PREDEFINED_COLORS[base_color_name] | opacity if PREDEFINED_COLORS.has_key?(base_color_name)
  end
  raise ArgumentError, "Unknown color name #{color_name}!"
end

- (Integer) int8_mult(a, b)

Multiplies two fractions using integer math, where the fractions are stored using an integer between 0 and 255. This method is used as a helper method for compositing colors using integer math.

This is a quicker implementation of ((a * b) / 255.0).round.



259
260
261
262
# File 'lib/chunky_png/color.rb', line 259

def int8_mult(a, b)
  t = a * b + 0x80
  ((t >> 8) + t) >> 8
end

- (Object) interpolate_quick(fg, bg, alpha)

Interpolates the foreground and background colors by the given alpha value. This also blends the alpha channels themselves.

A blending factor of 255 will give entirely the foreground, while a blending factor of 0 will give the background.



332
333
334
335
336
337
338
339
340
341
342
343
344
# File 'lib/chunky_png/color.rb', line 332

def interpolate_quick(fg, bg, alpha)
  return fg if alpha >= 255
  return bg if alpha <= 0

  alpha_com = 255 - alpha

  new_r = int8_mult(alpha, r(fg)) + int8_mult(alpha_com, r(bg))
  new_g = int8_mult(alpha, g(fg)) + int8_mult(alpha_com, g(bg))
  new_b = int8_mult(alpha, b(fg)) + int8_mult(alpha_com, b(bg))
  new_a = int8_mult(alpha, a(fg)) + int8_mult(alpha_com, a(bg))

  rgba(new_r, new_g, new_b, new_a)
end

- (Integer) opaque!(value)

Returns the opaque value of this color by removing the alpha channel.



226
227
228
# File 'lib/chunky_png/color.rb', line 226

def opaque!(value)
  value | 0x000000ff
end

- (true, false) opaque?(value)

Returns true if this color is fully opaque.



219
220
221
# File 'lib/chunky_png/color.rb', line 219

def opaque?(value)
  a(value) == 0x000000ff
end

- (Integer) parse(source)

Parses a color value given a numeric or string argument.

It supports color numbers, colors in hex notation and named HTML colors.



84
85
86
87
88
89
90
91
92
# File 'lib/chunky_png/color.rb', line 84

def parse(source)
  return source if source.kind_of?(Integer)
  case source.to_s
    when /^\d+$/; source.to_s.to_i
    when HEX3_COLOR_REGEXP, HEX6_COLOR_REGEXP; from_hex(source.to_s)
    when HTML_COLOR_REGEXP; html_color(source.to_s)
    else raise ArgumentError, "Don't know how to create a color from #{source.inspect}!"
  end
end

- (Integer) pass_bytesize(color_mode, depth, width, height)

Returns the number of bytes used for an image pass



806
807
808
809
# File 'lib/chunky_png/color.rb', line 806

def pass_bytesize(color_mode, depth, width, height)
  return 0 if width == 0 || height == 0
  (scanline_bytesize(color_mode, depth, width) + 1) * height
end

- (Integer) pixel_bitsize(color_mode, depth = 8)

Returns the size in bits of a pixel when it is stored using a given color mode.



785
786
787
# File 'lib/chunky_png/color.rb', line 785

def pixel_bitsize(color_mode, depth = 8)
  samples_per_pixel(color_mode) * depth
end

- (Integer) pixel_bytesize(color_mode, depth = 8)

Returns the size in bytes of a pixel when it is stored using a given color mode.



773
774
775
776
# File 'lib/chunky_png/color.rb', line 773

def pixel_bytesize(color_mode, depth = 8)
  return 1 if depth < 8
  (pixel_bitsize(color_mode, depth) + 7) >> 3
end

- (Integer) r(value)

Returns the red-component from the color value.



187
188
189
# File 'lib/chunky_png/color.rb', line 187

def r(value)
  (value & 0xff000000) >> 24
end

- (Integer) rgb(r, g, b)

Creates a new color using an r, g, b triple.



109
110
111
# File 'lib/chunky_png/color.rb', line 109

def rgb(r, g, b)
  r << 24 | g << 16 | b << 8 | 0xff
end

- (Integer) rgba(r, g, b, a)

Creates a new color using an r, g, b triple and an alpha value.



100
101
102
# File 'lib/chunky_png/color.rb', line 100

def rgba(r, g, b, a)
  r << 24 | g << 16 | b << 8 | a
end

- (Integer) samples_per_pixel(color_mode)

Returns the number of sample values per pixel.



756
757
758
759
760
761
762
763
764
765
# File 'lib/chunky_png/color.rb', line 756

def samples_per_pixel(color_mode)
  case color_mode
    when ChunkyPNG::COLOR_INDEXED;         1
    when ChunkyPNG::COLOR_TRUECOLOR;       3
    when ChunkyPNG::COLOR_TRUECOLOR_ALPHA; 4
    when ChunkyPNG::COLOR_GRAYSCALE;       1
    when ChunkyPNG::COLOR_GRAYSCALE_ALPHA; 2
    else raise ChunkyPNG::NotSupported, "Don't know the number of samples for this colormode: #{color_mode}!"
  end
end

- (Integer) scanline_bytesize(color_mode, depth, width)

Returns the number of bytes used per scanline.



795
796
797
# File 'lib/chunky_png/color.rb', line 795

def scanline_bytesize(color_mode, depth, width)
  ((pixel_bitsize(color_mode, depth) * width) + 7) >> 3
end

- (Integer) to_grayscale(color)

Converts a color to a fiting grayscale value. It will conserve the alpha channel.

This method will return a full color value, with the R, G, and B value set to the grayscale teint calcuated from the input color's R, G and B values.

See Also:



365
366
367
# File 'lib/chunky_png/color.rb', line 365

def to_grayscale(color)
  grayscale_alpha(grayscale_teint(color), a(color))
end

- (Array<Integer>) to_grayscale_alpha_bytes(color)

Returns an array with the grayscale teint and alpha channel values for this color.

This method expects the color to be grayscale, i.e. r, g, and b value to be equal and uses only the B channel. If you need to convert a color to grayscale first, see #to_grayscale.

See Also:



525
526
527
# File 'lib/chunky_png/color.rb', line 525

def to_grayscale_alpha_bytes(color)
  [b(color), a(color)] # assumption r == g == b
end

- (Array<Integer>) to_grayscale_bytes(color)

Returns an array with the grayscale teint value for this color.

This method expects the r, g, and b value to be equal, and the alpha channel will be discarded.



511
512
513
# File 'lib/chunky_png/color.rb', line 511

def to_grayscale_bytes(color)
  [b(color)] # assumption r == g == b
end

- (String) to_hex(color, include_alpha = true)

Returns a string representing this color using hex notation (i.e. #rrggbbaa).



483
484
485
# File 'lib/chunky_png/color.rb', line 483

def to_hex(color, include_alpha = true)
  include_alpha ? ('#%08x' % color) : ('#%06x' % [color >> 8])
end

- (Array<Integer>) to_truecolor_alpha_bytes(color)

Returns an array with the separate RGBA values for this color.



491
492
493
# File 'lib/chunky_png/color.rb', line 491

def to_truecolor_alpha_bytes(color)
  [r(color), g(color), b(color), a(color)]
end

- (Array<Integer>) to_truecolor_bytes(color)

Returns an array with the separate RGB values for this color. The alpha channel will be discarded.



500
501
502
# File 'lib/chunky_png/color.rb', line 500

def to_truecolor_bytes(color)
  [r(color), g(color), b(color)]
end