chunky_png 1.3.0 → 1.3.1

data/lib/chunky_png/canvas/stream_importing.rb

@@ -51,8 +51,8 @@ module ChunkyPNG
       # @param [#read, String] stream The stream to read the pixel data from.
       # @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
       def from_bgr_stream(width, height, stream)
-        string = ChunkyPNG::EXTRA_BYTE # Add a first byte to the first BGR triple.
-        string << stream.respond_to?(:read) ? stream.read(3 * width * height) : stream.to_s[0, 3 * width * height]
+        string = ChunkyPNG::EXTRA_BYTE.dup # Add a first byte to the first BGR triple.
+        string << (stream.respond_to?(:read) ? stream.read(3 * width * height) : stream.to_s[0, 3 * width * height])
         pixels = string.unpack("@1" << ('XV' * (width * height))).map { |color| color | 0x000000ff }
         self.new(width, height, pixels)
       end

data/lib/chunky_png/chunk.rb

@@ -1,8 +1,7 @@
 module ChunkyPNG
-  
   # A PNG datastream consists of multiple chunks. This module, and the classes
-  # contained within, help with handling these chunks. It supports both
-  # reading and writing chunks.
+  # contained within, help with handling these chunks. It supports both reading
+  # and writing chunks.
   #
   # All chunk types are instances of the {ChunkyPNG::Chunk::Base} class. For
   # some chunk types a specialized class is available, e.g. the IHDR chunk is
@@ -12,13 +11,11 @@ module ChunkyPNG
   #
   # @see ChunkyPNG::Datastream
   module Chunk
-
     # Reads a chunk from an IO stream.
     #
-    # @param [IO, #read] io The IO stream to read from.
+    # @param io [IO, #read] The IO stream to read from.
     # @return [ChunkyPNG::Chung::Base] The loaded chunk instance.
     def self.read(io)
-
       length, type = io.read(8).unpack('Na4')
       content      = io.read(length)
       crc          = io.read(4).unpack('N').first
@@ -27,13 +24,13 @@ module ChunkyPNG
 
       CHUNK_TYPES.fetch(type, Generic).read(type, content)
     end
-    
+
     # Verifies the CRC of a chunk.
-    # @param [String] type The chunk's type.
-    # @param [String] content The chunk's content.
-    # @param [Integer] content The chunk's content.
-    # @raise [RuntimeError] An exception is raised if the found CRC value
-    #    is not equal to the expected CRC value.
+    # @param type [String] The chunk's type.
+    # @param content [String] The chunk's content.
+    # @param found_crc [Integer] The chunk's found CRC value.
+    # @raise [RuntimeError] An exception is raised if the found CRC value is
+    #   not equal to the expected CRC value.
     def self.verify_crc!(type, content, found_crc)
       expected_crc = Zlib.crc32(content, Zlib.crc32(type))
       raise ChunkyPNG::CRCMismatch, "Chuck CRC mismatch!" if found_crc != expected_crc
@@ -47,15 +44,14 @@ module ChunkyPNG
     #
     # @abstract
     class Base
-      
       # The four-character type indicator for the chunk. This field is used to
       # find the correct class for a chunk when it is loaded from a PNG stream.
       # @return [String]
       attr_accessor :type
 
       # Initializes the chunk instance.
-      # @param [String] type The four character chunk type indicator.
-      # @param [Hash] attributes A hash of attributes to set on this chunk.
+      # @param type [String] The four character chunk type indicator.
+      # @param attributes [Hash] A hash of attributes to set on this chunk.
       def initialize(type, attributes = {})
         self.type = type
         attributes.each { |k, v| send("#{k}=", v) }
@@ -63,8 +59,8 @@ module ChunkyPNG
 
       # Writes the chunk to the IO stream, using the provided content.
       # The checksum will be calculated and appended to the stream.
-      # @param [IO] io The IO stream to write to.
-      # @param [String] content The content for this chunk.
+      # @param io [IO] The IO stream to write to.
+      # @param content [String] The content for this chunk.
       def write_with_crc(io, content)
         io << [content.length].pack('N') << type << content
         io << [Zlib.crc32(content, Zlib.crc32(type))].pack('N')
@@ -74,47 +70,44 @@ module ChunkyPNG
       #
       # It will call the +content+ method to get the content for this chunk,
       # and will calculate and append the checksum automatically.
-      # @param [IO] io The IO stream to write to.
+      # @param io [IO] The IO stream to write to.
       def write(io)
         write_with_crc(io, content || '')
       end
     end
 
-    # The Generic chunk type will read the content from the chunk as it, 
+    # The Generic chunk type will read the content from the chunk as it,
     # and will write it back as it was read.
     class Generic < Base
-
-      # The attribute to store the content from the chunk, which gets 
+      # The attribute to store the content from the chunk, which gets
       # written by the +write+ method.
       attr_accessor :content
 
-      
       def initialize(type, content = '')
         super(type, :content => content)
       end
 
       # Creates an instance, given the chunk's type and content.
-      # @param [String] type The four character chunk type indicator.
-      # @param [String] content The content read from the chunk.
+      # @param type [String] The four character chunk type indicator.
+      # @param content [String] The content read from the chunk.
       # @return [ChunkyPNG::Chunk::Generic] The new chunk instance.
       def self.read(type, content)
-        self.new(type, content)
+        new(type, content)
       end
     end
 
-    # The header (IHDR) chunk is the first chunk of every PNG image, and 
-    # contains information about the image: i.e. its width, height, color 
+    # The header (IHDR) chunk is the first chunk of every PNG image, and
+    # contains information about the image: i.e. its width, height, color
     # depth, color mode, compression method, filtering method and interlace
     # method.
     #
-    # ChunkyPNG supports all values for these variables that are defined in
-    # the PNG spec, except for color depth: Only 8-bit depth images are
-    # supported. Note that it is still possible to access the chunk for such
-    # an image, but ChunkyPNG will raise an exception if you try to access
-    # the pixel data.
+    # ChunkyPNG supports all values for these variables that are defined in the
+    # PNG spec, except for color depth: Only 8-bit depth images are supported.
+    # Note that it is still possible to access the chunk for such an image, but
+    # ChunkyPNG will raise an exception if you try to access the pixel data.
     class Header < Base
-
-      attr_accessor :width, :height, :depth, :color, :compression, :filtering, :interlace
+      attr_accessor :width, :height, :depth, :color, :compression, :filtering,
+                    :interlace
 
       def initialize(attrs = {})
         super('IHDR', attrs)
@@ -125,36 +118,45 @@ module ChunkyPNG
         @interlace   ||= ChunkyPNG::INTERLACING_NONE
       end
 
-      # Reads the 13 bytes of content from the header chunk to set the image attributes.
-      # @param [String] type The four character chunk type indicator (= "IHDR").
-      # @param [String] content The 13 bytes of content read from the chunk.
-      # @return [ChunkyPNG::Chunk::End] The new Header chunk instance with the 
-      #    variables set to the values according to the content.
+      # Reads the 13 bytes of content from the header chunk to set the image
+      # attributes.
+      # @param type [String] The four character chunk type indicator (= "IHDR").
+      # @param content [String] The 13 bytes of content read from the chunk.
+      # @return [ChunkyPNG::Chunk::End] The new Header chunk instance with the
+      #   variables set to the values according to the content.
       def self.read(type, content)
         fields = content.unpack('NNC5')
-        self.new(:width => fields[0],  :height => fields[1], :depth => fields[2], :color => fields[3],
-                       :compression => fields[4], :filtering => fields[5], :interlace => fields[6])
+        new(:width => fields[0],
+            :height => fields[1],
+            :depth => fields[2],
+            :color => fields[3],
+            :compression => fields[4],
+            :filtering => fields[5],
+            :interlace => fields[6])
       end
 
-      # Returns the content for this chunk when it gets written to a file, by packing the
-      # image information variables into the correct format.
+      # Returns the content for this chunk when it gets written to a file, by
+      # packing the image information variables into the correct format.
       # @return [String] The 13-byte content for the header chunk.
       def content
-        [width, height, depth, color, compression, filtering, interlace].pack('NNC5')
+        [width, height, depth, color, compression, filtering, interlace].
+          pack('NNC5')
       end
     end
 
-    # The End (IEND) chunk indicates the last chunk of a PNG stream. It does not
-    # contain any data.
+    # The End (IEND) chunk indicates the last chunk of a PNG stream. It does
+    # not contain any data.
     class End < Base
-      
+
       def initialize
         super('IEND')
       end
-      
+
       # Reads the END chunk. It will check if the content is empty.
-      # @param [String] type The four character chunk type indicator (= "IEND").
-      # @param [String] content The content read from the chunk. Should be empty.
+      # @param type [String] The four character chunk type indicator (=
+      #   "IEND").
+      # @param content [String] The content read from the chunk. Should be
+      #   empty.
       # @return [ChunkyPNG::Chunk::End] The new End chunk instance.
       # @raise [RuntimeError] Raises an exception if the content was not empty.
       def self.read(type, content)
@@ -173,46 +175,56 @@ module ChunkyPNG
     # 8-bit RGB colors this image is using.
     #
     # @see ChunkyPNG::Chunk::Transparency
-    # @see ChunkyPNG::Palette 
+    # @see ChunkyPNG::Palette
     class Palette < Generic
     end
 
     # A transparency (tRNS) chunk defines the transparency for an image.
     #
-    # * For indexed images, it contains the alpha channel for the colors defined in the Palette (PLTE) chunk.
-    # * For grayscale images, it contains the grayscale teint that should be considered fully transparent.
-    # * For truecolor images, it contains the color that should be considered fully transparent.
+    # * For indexed images, it contains the alpha channel for the colors
+    #   defined in the Palette (PLTE) chunk.
+    # * For grayscale images, it contains the grayscale teint that should be
+    #   considered fully transparent.
+    # * For truecolor images, it contains the color that should be considered
+    #   fully transparent.
     #
-    # Images having a color mode that already includes an alpha channel, this chunk should not be included.
+    # Images having a color mode that already includes an alpha channel, this
+    # chunk should not be included.
     #
     # @see ChunkyPNG::Chunk::Palette
     # @see ChunkyPNG::Palette
     class Transparency < Generic
-      
       # Returns the alpha channel for the palette of an indexed image.
       #
-      # This method should only be used for images having color mode ChunkyPNG::COLOR_INDEXED (3).
+      # This method should only be used for images having color mode
+      # ChunkyPNG::COLOR_INDEXED (3).
       #
-      # @return [Array<Integer>] Returns an array of alpha channel values [0-255].
+      # @return [Array<Integer>] Returns an array of alpha channel values
+      #   [0-255].
       def palette_alpha_channel
         content.unpack('C*')
       end
-      
+
       # Returns the truecolor entry to be replaced by transparent pixels,
       #
-      # This method should only be used for images having color mode ChunkyPNG::COLOR_TRUECOLOR (2).
+      # This method should only be used for images having color mode
+      # ChunkyPNG::COLOR_TRUECOLOR (2).
       #
       # @return [Integer] The color to replace with fully transparent pixels.
       def truecolor_entry(bit_depth)
-        values = content.unpack('nnn').map { |c| ChunkyPNG::Canvas.send(:"decode_png_resample_#{bit_depth}bit_value", c) }
+        values = content.unpack('nnn').map do |c|
+          ChunkyPNG::Canvas.send(:"decode_png_resample_#{bit_depth}bit_value", c)
+        end
         ChunkyPNG::Color.rgb(*values)
       end
 
       # Returns the grayscale entry to be replaced by transparent pixels.
       #
-      # This method should only be used for images having color mode ChunkyPNG::COLOR_GRAYSCALE (0).
+      # This method should only be used for images having color mode
+      # ChunkyPNG::COLOR_GRAYSCALE (0).
       #
-      # @return [Integer] The (grayscale) color to replace with fully transparent pixels.      
+      # @return [Integer] The (grayscale) color to replace with fully
+      #   transparent pixels.
       def grayscale_entry(bit_depth)
         value = ChunkyPNG::Canvas.send(:"decode_png_resample_#{bit_depth}bit_value", content.unpack('n')[0])
         ChunkyPNG::Color.grayscale(value)
@@ -220,16 +232,15 @@ module ChunkyPNG
     end
 
     class ImageData < Generic
-      
       def self.read(type, content)
         raise ExpectationFailed, 'The IDAT chunk should not be empty!' if content.bytesize == 0
         super
       end
-      
+
       def self.combine_chunks(data_chunks)
         Zlib::Inflate.inflate(data_chunks.map { |c| c.content }.join(''))
       end
-      
+
       def self.split_in_chunks(data, level = Zlib::DEFAULT_COMPRESSION, chunk_size = 2147483647)
         streamdata = Zlib::Deflate.deflate(data, level)
         # TODO: Split long streamdata over multiple chunks
@@ -237,16 +248,15 @@ module ChunkyPNG
       end
     end
 
-    # The Text (tEXt) chunk contains keyword/value metadata about the PNG stream.
-    # In this chunk, the value is stored uncompressed.
+    # The Text (tEXt) chunk contains keyword/value metadata about the PNG
+    # stream.  In this chunk, the value is stored uncompressed.
     #
-    # The tEXt chunk only supports Latin-1 encoded textual data. If you need UTF-8 
-    # support, check out the InternationalText chunk type.
+    # The tEXt chunk only supports Latin-1 encoded textual data. If you need
+    # UTF-8 support, check out the InternationalText chunk type.
     #
     # @see ChunkyPNG::Chunk::CompressedText
     # @see ChunkyPNG::Chunk::InternationalText
     class Text < Base
-
       attr_accessor :keyword, :value
 
       def initialize(keyword, value)
@@ -259,8 +269,8 @@ module ChunkyPNG
         new(keyword, value)
       end
 
-      # Creates the content to write to the stream, by concatenating the keyword
-      # with the value, joined by a null character.
+      # Creates the content to write to the stream, by concatenating the
+      # keyword with the value, joined by a null character.
       #
       # @return The content that should be written to the datastream.
       def content
@@ -268,14 +278,13 @@ module ChunkyPNG
       end
     end
 
-    # The CompressedText (zTXt) chunk contains keyword/value metadata about 
-    # the PNG stream. In this chunk, the value is compressed using Deflate
+    # The CompressedText (zTXt) chunk contains keyword/value metadata about the
+    # PNG stream. In this chunk, the value is compressed using Deflate
     # compression.
     #
     # @see ChunkyPNG::Chunk::CompressedText
     # @see ChunkyPNG::Chunk::InternationalText
     class CompressedText < Base
-
       attr_accessor :keyword, :value
 
       def initialize(keyword, value)
@@ -289,40 +298,49 @@ module ChunkyPNG
         new(keyword, Zlib::Inflate.inflate(value))
       end
 
-      # Creates the content to write to the stream, by concatenating the keyword
-      # with the deflated value, joined by a null character.
+      # Creates the content to write to the stream, by concatenating the
+      # keyword with the deflated value, joined by a null character.
       #
       # @return The content that should be written to the datastream.
       def content
-        [keyword, ChunkyPNG::COMPRESSION_DEFAULT, Zlib::Deflate.deflate(value)].pack('Z*Ca*')
+        [keyword, ChunkyPNG::COMPRESSION_DEFAULT, Zlib::Deflate.deflate(value)].
+          pack('Z*Ca*')
       end
     end
 
-    # The Text (iTXt) chunk contains keyword/value metadata about the PNG stream.
-    # The metadata in this chunk can be encoded using UTF-8 characters. Moreover,
-    # it is possible to define the language of the metadata, and give a translation
-    # of the keyword name. Finally, it supports bot compressed and uncompressed
-    # values.
-    # 
-    # @todo This chunk is currently not implemented, but merely read and written 
-    #    back intact.
+    # The Text (iTXt) chunk contains keyword/value metadata about the PNG
+    # stream.
+    #
+    # The metadata in this chunk can be encoded using UTF-8 characters.
+    # Moreover, it is possible to define the language of the metadata, and give
+    # a translation of the keyword name. Finally, it supports bot compressed
+    # and uncompressed values.
+    #
+    # @todo This chunk is currently not implemented, but merely read and
+    #   written back intact.
     #
     # @see ChunkyPNG::Chunk::Text
     # @see ChunkyPNG::Chunk::CompressedText
     class InternationalText < Generic
-      
       # TODO
     end
 
-    # Maps chunk types to classes, based on the four byte chunk type indicator at the
-    # beginning of a chunk.
+    # Maps chunk types to classes, based on the four byte chunk type indicator
+    # at the beginning of a chunk.
     #
-    # If a chunk type is not specified in this hash, the Generic chunk type will be used.
+    # If a chunk type is not specified in this hash, the Generic chunk type
+    # will be used.
     #
     # @see ChunkyPNG::Chunk.read
     CHUNK_TYPES = {
-      'IHDR' => Header, 'IEND' => End, 'IDAT' => ImageData, 'PLTE' => Palette, 'tRNS' => Transparency,
-      'tEXt' => Text, 'zTXt' => CompressedText, 'iTXt' => InternationalText
+      'IHDR' => Header,
+      'IEND' => End,
+      'IDAT' => ImageData,
+      'PLTE' => Palette,
+      'tRNS' => Transparency,
+      'tEXt' => Text,
+      'zTXt' => CompressedText,
+      'iTXt' => InternationalText,
     }
   end
 end

data/lib/chunky_png/color.rb

@@ -1,5 +1,5 @@
 module ChunkyPNG
-  
+
   # Factory method to return a color value, based on the arguments given.
   #
   # @overload Color(r, g, b, a)
@@ -12,15 +12,18 @@ module ChunkyPNG
   #
   # @overload Color(hex_value, opacity = nil)
   #   @param (see ChunkyPNG::Color.from_hex)
-  #   @return [Integer] The hex color value, with the opacity applied if one was given.
+  #   @return [Integer] The hex color value, with the opacity applied if one
+  #     was given.
   #
   # @overload Color(color_name, opacity = nil)
   #   @param (see ChunkyPNG::Color.html_color)
-  #   @return [Integer] The hex color value, with the opacity applied if one was given.
+  #   @return [Integer] The hex color value, with the opacity applied if one
+  #     was given.
   #
   # @overload Color(color_value, opacity = nil)
   #   @param [Integer, :to_i] The color value.
-  #   @return [Integer] The color value, with the opacity applied if one was given.
+  #   @return [Integer] The color value, with the opacity applied if one was
+  #     given.
   #
   # @return [Integer] The determined color value as RGBA integer.
   # @raise [ArgumentError] if the arguments weren't understood as a color.
@@ -54,7 +57,7 @@ module ChunkyPNG
 
     # @return [Integer] The maximum value of each color component.
     MAX = 0xff
-    
+
     # @private
     # @return [Regexp] The regexp to parse 3-digit hex color values.
     HEX3_COLOR_REGEXP  = /\A(?:#|0x)?([0-9a-f]{3})\z/i
@@ -66,7 +69,7 @@ module ChunkyPNG
     # @private
     # @return [Regexp] The regexp to parse named color values.
     HTML_COLOR_REGEXP = /^([a-z][a-z_ ]+[a-z])(?:\ ?\@\ ?(1\.0|0\.\d+))?$/i
-    
+
     ####################################################################
     # CONSTRUCTING COLOR VALUES
     ####################################################################
@@ -76,7 +79,8 @@ module ChunkyPNG
     # It supports color numbers, colors in hex notation and named HTML colors.
     #
     # @param [Integer, String] The color value.
-    # @return [Integer] The color value, with the opacity applied if one was given.
+    # @return [Integer] The color value, with the opacity applied if one was
+    #   given.
     def parse(source)
       return source if source.kind_of?(Integer)
       case source.to_s
@@ -107,14 +111,16 @@ module ChunkyPNG
     end
 
     # Creates a new color using a grayscale teint.
-    # @param [Integer] teint The grayscale teint (0-255), will be used as r, g, and b value.
+    # @param [Integer] teint The grayscale teint (0-255), will be used as r, g,
+    #   and b value.
     # @return [Integer] The newly constructed color value.
     def grayscale(teint)
       teint << 24 | teint << 16 | teint << 8 | 0xff
     end
 
     # Creates a new color using a grayscale teint and alpha value.
-    # @param [Integer] teint The grayscale teint (0-255), will be used as r, g, and b value.
+    # @param [Integer] teint The grayscale teint (0-255), will be used as r, g,
+    #   and b value.
     # @param [Integer] a The opacity (0-255)
     # @return [Integer] The newly constructed color value.
     def grayscale_alpha(teint, a)
@@ -127,7 +133,7 @@ module ChunkyPNG
 
     # Creates a color by unpacking an rgb triple from a string.
     #
-    # @param [String] stream The string to load the color from. It should be 
+    # @param [String] stream The string to load the color from. It should be
     #     at least 3 + pos bytes long.
     # @param [Integer] pos The position in the string to load the triple from.
     # @return [Integer] The newly constructed color value.
@@ -137,15 +143,15 @@ module ChunkyPNG
 
     # Creates a color by unpacking an rgba triple from a string
     #
-    # @param [String] stream The string to load the color from. It should be 
+    # @param [String] stream The string to load the color from. It should be
     #      at least 4 + pos bytes long.
     # @param [Integer] pos The position in the string to load the triple from.
     # @return [Integer] The newly constructed color value.
     def from_rgba_stream(stream, pos = 0)
       rgba(*stream.unpack("@#{pos}C4"))
     end
-    
-    # Creates a color by converting it from a string in hex notation. 
+
+    # 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.
@@ -181,7 +187,7 @@ module ChunkyPNG
     def r(value)
       (value & 0xff000000) >> 24
     end
-    
+
     # Returns the green-component from the color value.
     #
     # @param [Integer] value The color value.
@@ -189,7 +195,7 @@ module ChunkyPNG
     def g(value)
       (value & 0x00ff0000) >> 16
     end
-    
+
     # Returns the blue-component from the color value.
     #
     # @param [Integer] value The color value.
@@ -197,7 +203,7 @@ module ChunkyPNG
     def b(value)
       (value & 0x0000ff00) >> 8
     end
-    
+
     # Returns the alpha channel value for the color value.
     #
     # @param [Integer] value The color value.
@@ -205,7 +211,7 @@ module ChunkyPNG
     def a(value)
       value & 0x000000ff
     end
-    
+
     # Returns true if this color is fully opaque.
     #
     # @param [Integer] value The color to test.
@@ -213,14 +219,14 @@ module ChunkyPNG
     def opaque?(value)
       a(value) == 0x000000ff
     end
-    
+
     # Returns the opaque value of this color by removing the alpha channel.
     # @param [Integer] value The color to transform.
     # @return [Integer] The opaque color
     def opaque!(value)
       value | 0x000000ff
     end
-    
+
     # Returns true if this color is fully transparent.
     #
     # @param [Integer] value The color to test.
@@ -228,7 +234,7 @@ module ChunkyPNG
     def grayscale?(value)
       r(value) == b(value) && b(value) == g(value)
     end
-    
+
     # Returns true if this color is fully transparent.
     #
     # @param [Integer] value The color to test.
@@ -241,9 +247,9 @@ module ChunkyPNG
     # ALPHA COMPOSITION
     ####################################################################
 
-    # 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.
+    # 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.
     #
@@ -257,8 +263,8 @@ module ChunkyPNG
 
     # 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.
+    # This version is faster than the version based on floating point math, so
+    # this compositing function is used by default.
     #
     # @param [Integer] fg The foreground color.
     # @param [Integer] bg The foreground color.
@@ -267,7 +273,7 @@ module ChunkyPNG
     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))
@@ -278,9 +284,9 @@ module ChunkyPNG
 
     # 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.
+    # 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.
     #
     # @param [Integer] fg The foreground color.
     # @param [Integer] bg The foreground color.
@@ -289,7 +295,7 @@ module ChunkyPNG
     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
@@ -302,8 +308,8 @@ module ChunkyPNG
     end
 
     alias :compose :compose_quick
-    
-    # Blends the foreground and background color by taking the average of 
+
+    # Blends the foreground and background color by taking the average of
     # the components.
     #
     # @param [Integer] fg The foreground color.
@@ -313,8 +319,8 @@ module ChunkyPNG
       (fg + bg) >> 1
     end
 
-    # Interpolates the foreground and background colors by the given alpha value.
-    # This also blends the alpha channels themselves.
+    # 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.
@@ -326,37 +332,39 @@ module ChunkyPNG
     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))
-      
-      return rgba(new_r, new_g, new_b, new_a)
+
+      rgba(new_r, new_g, new_b, new_a)
     end
 
     # Calculates the grayscale teint of an RGB color.
     #
-    # @param [Integer] color The color to convert.    
+    # @param [Integer] color The color to convert.
     # @return [Integer] The grayscale teint of the input color, 0-255.
     def grayscale_teint(color)
       (r(color) * 0.3 + g(color) * 0.59 + b(color) * 0.11).round
     end
-    
+
     # 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.
+    # 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.
     #
     # @param [Integer] color The color to convert.
-    # @return [Integer] The input color, converted to the best fitting grayscale.
+    # @return [Integer] The input color, converted to the best fitting
+    #   grayscale.
     # @see #grayscale_teint
     def to_grayscale(color)
       grayscale_alpha(grayscale_teint(color), a(color))
-    end    
+    end
 
     # Lowers the intensity of a color, by lowering its alpha by a given factor.
     # @param [Integer] color The color to adjust.
@@ -366,21 +374,23 @@ module ChunkyPNG
       new_alpha = int8_mult(a(color), factor)
       (color & 0xffffff00) | new_alpha
     end
-    
+
     # 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 
+    # 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.
     #
     # @param [Integer] color The color that was the result of compositing.
-    # @param [Integer] mask The opaque variant of the color that was being composed
+    # @param [Integer] mask The opaque variant of the color that was being
+    #   composed
     # @param [Integer] bg The background color on which the color was composed.
-    # @param [Integer] tolerance The decomposition tolerance level, a value between 0 and 255.
-    # @return [Integer] The decomposed color,a variant of the masked color with the 
-    #    alpha channel set to an appropriate value.
+    # @param [Integer] tolerance The decomposition tolerance level, a value
+    #   between 0 and 255.
+    # @return [Integer] The decomposed color, a variant of the masked color
+    #   with the alpha channel set to an appropriate value.
     def decompose_color(color, mask, bg, tolerance = 1)
       if alpha_decomposable?(color, mask, bg, tolerance)
         mask & 0xffffff00 | decompose_alpha(color, mask, bg)
@@ -388,62 +398,71 @@ module ChunkyPNG
         mask & 0xffffff00
       end
     end
-    
+
     # 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. 
+    # all of which should be opaque.
     #
     # @param [Integer] color The color that was the result of compositing.
-    # @param [Integer] mask The opaque variant of the color that was being composed
+    # @param [Integer] mask The opaque variant of the color that was being
+    #   composed
     # @param [Integer] bg The background color on which the color was composed.
-    # @param [Integer] tolerance The decomposition tolerance level, a value between 0 and 255.
-    # @return [Boolean] True if the alpha component can be decomposed successfully.
+    # @param [Integer] tolerance The decomposition tolerance level, a value
+    #   between 0 and 255.
+    # @return [Boolean] True if the alpha component can be decomposed
+    #   successfully.
     # @see #decompose_alpha
     def alpha_decomposable?(color, mask, bg, tolerance = 1)
       components = decompose_alpha_components(color, mask, bg)
-      sum = components.inject(0) { |a,b| a + b } 
+      sum = components.inject(0) { |a,b| a + b }
       max = components.max * 3
-      return components.max <= 255 && components.min >= 0 && (sum + tolerance * 3) >= max
+      components.max <= 255 && components.min >= 0 && (sum + tolerance * 3) >= max
     end
-    
-    # Decomposes the alpha channel value given the resulting color, the mask color 
-    # and a background color, all of which should be opaque.
+
+    # 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.
+    # 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.
     #
     # @param [Integer] color The color that was the result of compositing.
-    # @param [Integer] mask The opaque variant of the color that was being composed
+    # @param [Integer] mask The opaque variant of the color that was being
+    #   composed
     # @param [Integer] bg The background color on which the color was composed.
-    # @return [Integer] The best fitting alpha channel, a value between 0 and 255.
+    # @return [Integer] The best fitting alpha channel, a value between 0 and
+    #   255.
     # @see #alpha_decomposable?
     def decompose_alpha(color, mask, bg)
       components = decompose_alpha_components(color, mask, bg)
       (components.inject(0) { |a,b| a + b } / 3.0).round
     end
-    
+
     # Decomposes an alpha channel for either the r, g or b color channel.
-    # @param [:r, :g, :b] channel The channel to decompose the alpha channel from.
+    # @param [:r, :g, :b] channel The channel to decompose the alpha channel
+    #   from.
     # @param [Integer] color The color that was the result of compositing.
-    # @param [Integer] mask The opaque variant of the color that was being composed
+    # @param [Integer] mask The opaque variant of the color that was being
+    #   composed
     # @param [Integer] bg The background color on which the color was composed.
     # @return [Integer] The decomposed alpha value for the channel.
     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
-    
+
     # Decomposes the alpha channels for the r, g and b color channel.
     # @param [Integer] color The color that was the result of compositing.
-    # @param [Integer] mask The opaque variant of the color that was being composed
-    # @param [Integer] bg The background color on which the color was composed.    
-    # @return [Array<Integer>] The decomposed alpha values for the r, g and b channels.
+    # @param [Integer] mask The opaque variant of the color that was being
+    #   composed
+    # @param [Integer] bg The background color on which the color was composed.
+    # @return [Array<Integer>] The decomposed alpha values for the r, g and b
+    #   channels.
     def decompose_alpha_components(color, mask, bg)
       [
         decompose_alpha_component(:r, color, mask, bg),
@@ -456,7 +475,8 @@ module ChunkyPNG
     # CONVERSIONS
     ####################################################################
 
-    # Returns a string representing this color using hex notation (i.e. #rrggbbaa).
+    # Returns a string representing this color using hex notation (i.e.
+    # #rrggbbaa).
     #
     # @param [Integer] value The color to convert.
     # @return [String] The color in hex notation, starting with a pound sign.
@@ -472,8 +492,8 @@ module ChunkyPNG
       [r(color), g(color), b(color), a(color)]
     end
 
-    # Returns an array with the separate RGB values for this color.
-    # The alpha channel will be discarded.
+    # Returns an array with the separate RGB values for this color. The alpha
+    # channel will be discarded.
     #
     # @param [Integer] color The color to convert.
     # @return [Array<Integer>] An array with 3 Integer elements.
@@ -483,7 +503,7 @@ module ChunkyPNG
 
     # 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 
+    # This method expects the r, g, and b value to be equal, and the alpha
     # channel will be discarded.
     #
     # @param [Integer] color The grayscale color to convert.
@@ -492,189 +512,220 @@ module ChunkyPNG
       [b(color)] # assumption r == g == b
     end
 
-    # Returns an array with the grayscale teint and alpha channel values
-    # for this 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}.
+    # 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}.
     #
     # @param [Integer] color The grayscale color to convert.
     # @return [Array<Integer>] An array with 2 Integer elements.
-    # @see #to_grascale
+    # @see #to_grayscale
     def to_grayscale_alpha_bytes(color)
       [b(color), a(color)] # assumption r == g == b
     end
 
+    ####################################################################
+    # COMPARISON
+    ####################################################################
+
+    # 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.
+    #
+    # @param color_a [Integer]
+    # @param color_b [Integer]
+    # @return [Float]
+    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
+
+    # Could be simplified as MAX * 2, but this format mirrors the math in
+    # {#euclidean_distance_rgba}
+    # @return [Float] The maximum Euclidean distance of two RGBA colors.
+    MAX_EUCLIDEAN_DISTANCE_RGBA = Math.sqrt(MAX**2 * 4)
+
     ####################################################################
     # COLOR CONSTANTS
     ####################################################################
 
     # @return [Hash<Symbol, Integer>] All the predefined color names in HTML.
     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,
+      :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
+      :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
     }
-    
+
     # Gets a color value based on a HTML color name.
-    # 
-    # The color name is flexible. E.g. <tt>'yellowgreen'</tt>, <tt>'Yellow green'</tt>, 
-    # <tt>'YellowGreen'</tt>, <tt>'YELLOW_GREEN'</tt> and <tt>:yellow_green</tt> will
-    # all return the same color value.
-    #
-    # You can include a opacity level in the color name (e.g. <tt>'red @ 0.5'</tt>) or give
-    # an explicit opacity value as second argument. If no opacity value is given, the color
-    # will be fully opaque.
-    #
-    # @param [Symbol, String] color_name The color name. It may include an opacity specifier
-    #   like <tt>@ 0.8</tt> to set the color's opacity.
-    # @param [Integer] opacity The opacity value for the color between 0 and 255. Overrides 
-    #   any opacity value given in the color name.
+    #
+    # The color name is flexible. E.g. <tt>'yellowgreen'</tt>, <tt>'Yellow
+    # green'</tt>, <tt>'YellowGreen'</tt>, <tt>'YELLOW_GREEN'</tt> and
+    # <tt>:yellow_green</tt> will all return the same color value.
+    #
+    # You can include a opacity level in the color name (e.g. <tt>'red @
+    # 0.5'</tt>) or give an explicit opacity value as second argument. If no
+    # opacity value is given, the color will be fully opaque.
+    #
+    # @param [Symbol, String] color_name The color name. It may include an
+    #   opacity specifier like <tt>@ 0.8</tt> to set the color's opacity.
+    # @param [Integer] opacity The opacity value for the color between 0 and
+    #   255. Overrides any opacity value given in the color name.
     # @return [Integer] The color value.
     # @raise [ChunkyPNG::Exception] If the color name was not recognized.
     def html_color(color_name, opacity = nil)
@@ -709,37 +760,45 @@ module ChunkyPNG
         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 numer of samples for this colormode: #{color_mode}!"
+        else raise ChunkyPNG::NotSupported, "Don't know the number of samples for this colormode: #{color_mode}!"
       end
     end
 
-    # Returns the size in bytes of a pixel when it is stored using a given color mode.
-    # @param [Integer] color_mode The color mode in which the pixels are stored.
+    # Returns the size in bytes of a pixel when it is stored using a given
+    # color mode.
+    #
+    # @param [Integer] color_mode The color mode in which the pixels are
+    #   stored.
     # @return [Integer] The number of bytes used per pixel in a datastream.
     def pixel_bytesize(color_mode, depth = 8)
       return 1 if depth < 8
       (pixel_bitsize(color_mode, depth) + 7) >> 3
     end
-    
-    # Returns the size in bits of a pixel when it is stored using a given color mode.
-    # @param [Integer] color_mode The color mode in which the pixels are stored.
+
+    # Returns the size in bits of a pixel when it is stored using a given color
+    # mode.
+    #
+    # @param [Integer] color_mode The color mode in which the pixels are
+    #   stored.
     # @param [Integer] depth The color depth of the pixels.
     # @return [Integer] The number of bytes used per pixel in a datastream.
     def pixel_bitsize(color_mode, depth = 8)
       samples_per_pixel(color_mode) * depth
     end
-    
+
     # Returns the number of bytes used per scanline.
-    # @param [Integer] color_mode The color mode in which the pixels are stored.
+    # @param [Integer] color_mode The color mode in which the pixels are
+    #   stored.
     # @param [Integer] depth The color depth of the pixels.
     # @param [Integer] width The number of pixels per scanline.
     # @return [Integer] The number of bytes used per scanline in a datastream.
     def scanline_bytesize(color_mode, depth, width)
       ((pixel_bitsize(color_mode, depth) * width) + 7) >> 3
     end
-    
+
     # Returns the number of bytes used for an image pass
-    # @param [Integer] color_mode The color mode in which the pixels are stored.
+    # @param [Integer] color_mode The color mode in which the pixels are
+    #   stored.
     # @param [Integer] depth The color depth of the pixels.
     # @param [Integer] width The width of the image pass.
     # @param [Integer] width The height of the image pass.