bench9000 0.1

data/vendor/chunky_png/lib/chunky_png/compatibility.rb

@@ -0,0 +1,15 @@
+# Define the byte-operators on a string if they're not defined (Ruby 1.8)
+
+class String
+  alias_method :getbyte, :[]    unless method_defined?(:getbyte)
+  alias_method :setbyte, :[]=   unless method_defined?(:setbyte)
+  alias_method :bytesize, :size unless method_defined?(:bytesize)
+end
+
+module Enumerable
+  unless method_defined?(:minmax)
+    def minmax
+      [min, max]
+    end
+  end
+end

data/vendor/chunky_png/lib/chunky_png/datastream.rb

@@ -0,0 +1,185 @@
+module ChunkyPNG
+
+  # The Datastream class represents a PNG formatted datastream. It supports
+  # both reading from and writing to strings, streams and files.
+  #
+  # A PNG datastream begins with the PNG signature, and than contains multiple
+  # chunks, starting with a header (IHDR) chunk and finishing with an end
+  # (IEND) chunk.
+  #
+  # @see ChunkyPNG::Chunk
+  class Datastream
+
+    # The signature that each PNG file or stream should begin with.
+    SIGNATURE = ChunkyPNG.force_binary([137, 80, 78, 71, 13, 10, 26, 10].pack('C8'))
+
+    # The header chunk of this datastream.
+    # @return [ChunkyPNG::Chunk::Header]
+    attr_accessor :header_chunk
+
+    # All other chunks in this PNG file.
+    # @return [Array<ChunkyPNG::Chunk::Generic>]
+    attr_accessor :other_chunks
+
+    # The chunk containing the image's palette.
+    # @return [ChunkyPNG::Chunk::Palette]
+    attr_accessor :palette_chunk
+
+    # The chunk containing the transparency information of the palette.
+    # @return [ChunkyPNG::Chunk::Transparency]
+    attr_accessor :transparency_chunk
+
+    # The chunks that together compose the images pixel data.
+    # @return [Array<ChunkyPNG::Chunk::ImageData>]
+    attr_accessor :data_chunks
+
+    # The empty chunk that signals the end of this datastream
+    # @return [ChunkyPNG::Chunk::Header]
+    attr_accessor :end_chunk
+
+    # Initializes a new Datastream instance.
+    def initialize
+      @other_chunks = []
+      @data_chunks  = []
+    end
+
+    ##############################################################################
+    # LOADING DATASTREAMS
+    ##############################################################################
+
+    class << self
+
+      # Reads a PNG datastream from a string.
+      # @param [String] str The PNG encoded string to load from.
+      # @return [ChunkyPNG::Datastream] The loaded datastream instance.
+      def from_blob(str)
+        from_io(StringIO.new(str))
+      end
+
+      alias :from_string :from_blob
+
+      # Reads a PNG datastream from a file.
+      # @param [String] filename The path of the file to load from.
+      # @return [ChunkyPNG::Datastream] The loaded datastream instance.
+      def from_file(filename)
+        ds = nil
+        File.open(filename, 'rb') { |f| ds = from_io(f) }
+        ds
+      end
+
+      # Reads a PNG datastream from an input stream
+      # @param [IO] io The stream to read from.
+      # @return [ChunkyPNG::Datastream] The loaded datastream instance.
+      def from_io(io)
+        verify_signature!(io)
+
+        ds = self.new
+        until io.eof?
+          chunk = ChunkyPNG::Chunk.read(io)
+          case chunk
+            when ChunkyPNG::Chunk::Header;       ds.header_chunk = chunk
+            when ChunkyPNG::Chunk::Palette;      ds.palette_chunk = chunk
+            when ChunkyPNG::Chunk::Transparency; ds.transparency_chunk = chunk
+            when ChunkyPNG::Chunk::ImageData;    ds.data_chunks << chunk
+            when ChunkyPNG::Chunk::End;          ds.end_chunk = chunk
+            else ds.other_chunks << chunk
+          end
+        end
+        return ds
+      end
+
+      # Verifies that the current stream is a PNG datastream by checking its signature.
+      #
+      # This method reads the PNG signature from the stream, setting the current position
+      # of the stream directly after the signature, where the IHDR chunk should begin.
+      #
+      # @param [IO] io The stream to read the PNG signature from.
+      # @raise [RuntimeError] An exception is raised if the PNG signature is not found at
+      #    the beginning of the stream.
+      def verify_signature!(io)
+        signature = io.read(ChunkyPNG::Datastream::SIGNATURE.length)
+        unless ChunkyPNG.force_binary(signature) == ChunkyPNG::Datastream::SIGNATURE
+          raise ChunkyPNG::SignatureMismatch, "PNG signature not found, found #{signature.inspect} instead of #{ChunkyPNG::Datastream::SIGNATURE.inspect}!"
+        end
+      end
+    end
+
+    ##################################################################################
+    # CHUNKS
+    ##################################################################################
+
+    # Enumerates the chunks in this datastream.
+    #
+    # This will iterate over the chunks using the order in which the chunks
+    # should appear in the PNG file.
+    #
+    # @yield [chunk] Yields the chunks in this datastream, one by one in the correct order.
+    # @yieldparam [ChunkyPNG::Chunk::Base] chunk A chunk in this datastream.
+    # @see ChunkyPNG::Datastream#chunks
+    def each_chunk
+      yield(header_chunk)
+      other_chunks.each { |chunk| yield(chunk) }
+      yield(palette_chunk)      if palette_chunk
+      yield(transparency_chunk) if transparency_chunk
+      data_chunks.each  { |chunk| yield(chunk) }
+      yield(end_chunk)
+    end
+
+    # Returns an enumerator instance for this datastream's chunks.
+    # @return [Enumerable::Enumerator] An enumerator for the :each_chunk method.
+    # @see ChunkyPNG::Datastream#each_chunk
+    def chunks
+      enum_for(:each_chunk)
+    end
+    
+    # Returns all the textual metadata key/value pairs as hash.
+    # @return [Hash] A hash containing metadata fields and their values.
+    def metadata
+      metadata = {}
+      other_chunks.select do |chunk|
+        metadata[chunk.keyword] = chunk.value if chunk.respond_to?(:keyword)
+      end
+      metadata
+    end
+   
+    # Returns the uncompressed image data, combined from all the IDAT chunks
+    # @return [String] The uncompressed image data for this datastream
+    def imagedata
+      ChunkyPNG::Chunk::ImageData.combine_chunks(data_chunks)
+    end
+
+    ##################################################################################
+    # WRITING DATASTREAMS
+    ##################################################################################
+
+    # Returns an empty stream using binary encoding that can be used as stream to encode to.
+    # @return [String] An empty, binary string.
+    def self.empty_bytearray
+      ChunkyPNG::EMPTY_BYTEARRAY.dup
+    end
+
+    # Writes the datastream to the given output stream.
+    # @param [IO] io The output stream to write to.
+    def write(io)
+      io << SIGNATURE
+      each_chunk { |c| c.write(io) }
+    end
+
+    # Saves this datastream as a PNG file.
+    # @param [String] filename The filename to use.
+    def save(filename)
+      File.open(filename, 'wb') { |f| write(f) }
+    end
+
+    # Encodes this datastream into a string.
+    # @return [String] The encoded PNG datastream.
+    def to_blob
+      str = StringIO.new
+      write(str)
+      return str.string
+    end
+
+    alias :to_string :to_blob
+    alias :to_s :to_blob
+  end
+end

data/vendor/chunky_png/lib/chunky_png/dimension.rb

@@ -0,0 +1,113 @@
+module ChunkyPNG
+  
+  # Creates a {ChunkyPNG::Dimension} instance using arguments that can be interpreted 
+  # as width and height.
+  # 
+  # @overload Dimension(width, height)
+  #   @param [Integer] width The width-component of the dimension.
+  #   @param [Integer] height The height-component of the dimension.
+  #   @return [ChunkyPNG::Dimension] The instantiated dimension.
+  #
+  # @overload Dimension(string)
+  #   @param [String] string A string from which a width and height value can be parsed, e.g.
+  #      <tt>'10x20'</tt> or <tt>'[10, 20]'</tt>.
+  #   @return [ChunkyPNG::Dimension] The instantiated dimension.
+  #
+  # @overload Dimension(ary)
+  #   @param [Array] ary An array with the desired width as first element and the
+  #      desired height as second element, e.g. <tt>[10, 20]</tt>. 
+  #   @return [ChunkyPNG::Dimension] The instantiated dimension.
+  #
+  # @overload Dimension(hash)
+  #   @param [Hash] hash An hash with a <tt>'height'</tt> or <tt>:height</tt> key for the
+  #      desired height and with a <tt>'width'</tt> or <tt>:width</tt> key for the desired
+  #      width.
+  #   @return [ChunkyPNG::Dimension] The instantiated dimension.
+  #
+  # @return [ChunkyPNG::Dimension] The dimension created by this factory method.
+  # @raise [ArgumentError] If the argument(s) given where not understood as a dimension.
+  # @see ChunkyPNG::Dimension
+  def self.Dimension(*args)
+
+    case args.length
+      when 2; ChunkyPNG::Dimension.new(*args)
+      when 1; case source = args.first
+          when ChunkyPNG::Dimension; source
+          when ChunkyPNG::Point; ChunkyPNG::Dimension.new(source.x, source.y)
+          when Array; ChunkyPNG::Dimension.new(source[0], source[1])
+          when Hash;  ChunkyPNG::Dimension.new(source[:width] || source['width'], source[:height] || source['height'])
+          when ChunkyPNG::Dimension::DIMENSION_REGEXP; ChunkyPNG::Dimension.new($1, $2)
+          else
+            if source.respond_to?(:width) && source.respond_to?(:height)
+              ChunkyPNG::Dimension.new(source.width, source.height)
+            else
+              raise ArgumentError, "Don't know how to construct a point from #{source.inspect}!"
+            end
+        end
+      else raise ArgumentError, "Don't know how to construct a point from #{args.inspect}!"
+    end
+  end
+  
+  # Class that represents the dimension of something, e.g. a {ChunkyPNG::Canvas}.
+  #
+  # This class contains some methods to simplify performing dimension related checks.
+  class Dimension
+
+    # @return [Regexp] The regexp to parse dimensions from a string.
+    # @private
+    DIMENSION_REGEXP = /^[\(\[\{]?(\d+)\s*[x,]?\s*(\d+)[\)\]\}]?$/
+
+    # @return [Integer] The width-component of this dimension.
+    attr_accessor :width
+    
+    # @return [Integer] The height-component of this dimension.
+    attr_accessor :height
+    
+    # Initializes a new dimension instance.
+    # @param [Integer] width The width-component of the new dimension.
+    # @param [Integer] height The height-component of the new dimension.
+    def initialize(width, height)
+      @width, @height = width.to_i, height.to_i
+    end
+    
+    # Returns the area of this dimension.
+    # @return [Integer] The area in number of pixels.
+    def area
+      width * height
+    end
+    
+    # Checks whether a point is within bounds of this dimension.
+    # @param [ChunkyPNG::Point, ...] A point-like to bounds-check.
+    # @return [true, false] True iff the x and y coordinate fall in this dimension.
+    # @see ChunkyPNG.Point
+    def include?(*point_like)
+      point = ChunkyPNG::Point(*point_like)
+      point.x >= 0 && point.x < width && point.y >= 0 && point.y < height
+    end
+    
+    # Checks whether 2 dimensions are identical.
+    # @param [ChunkyPNG::Dimension] The dimension to compare with.
+    # @return [true, false] <tt>true</tt> iff width and height match.
+    def eql?(other)
+      other.width == width && other.height == height
+    end
+    
+    alias_method :==, :eql?
+    
+    # Compares the size of 2 dimensions.
+    # @param [ChunkyPNG::Dimension] The dimension to compare with.
+    # @return [-1, 0, 1] -1 if the other dimension has a larger area, 1 of this
+    #   dimension is larger, 0 if both are identical in size.
+    def <=>(other)
+      other.area <=> area
+    end
+    
+    # Casts this dimension into an array.
+    # @return [Array<Integer>] <tt>[width, height]</tt> for this dimension.
+    def to_a
+      [width, height]
+    end
+    
+    alias_method :to_ary, :to_a
+  end
+end

data/vendor/chunky_png/lib/chunky_png/image.rb

@@ -0,0 +1,79 @@
+module ChunkyPNG
+
+  # ChunkyPNG::Image is an extension of the {ChunkyPNG::Canvas} class, that
+  # also includes support for metadata.
+  #
+  # @see ChunkyPNG::Canvas
+  class Image < Canvas
+
+    # The minimum size of bytes the value of a metadata field should be before compression
+    # is enabled for the chunk.
+    METADATA_COMPRESSION_TRESHOLD = 300
+    
+    # @return [Hash] The hash of metadata fields for this PNG image.
+    attr_accessor :metadata
+    
+    # Initializes a new ChunkyPNG::Image instance.
+    # @param [Integer] width The width of the new image.
+    # @param [Integer] height The height of the new image.
+    # @param [Integer] bg_color The background color of the new image.
+    # @param [Hash] metadata A hash of metadata fields and values for this image.
+    # @see ChunkyPNG::Canvas#initialize
+    def initialize(width, height, bg_color = ChunkyPNG::Color::TRANSPARENT, metadata = {})
+      super(width, height, bg_color)
+      @metadata = metadata
+    end
+    
+    # Initializes a copy of another ChunkyPNG::Image instance.
+    #
+    # @param [ChunkyPNG::Image] other The other image to copy.
+    def initialize_copy(other)
+      super(other)
+      @metadata = other.metadata
+    end
+    
+    # Returns the metadata for this image as PNG chunks.
+    #
+    # Chunks will either be of the {ChunkyPNG::Chunk::Text} type for small
+    # values (in bytes), or of the {ChunkyPNG::Chunk::CompressedText} type
+    # for values that are larger in size.
+    #
+    # @return [Array<ChunkyPNG::Chunk>] An array of metadata chunks.
+    # @see ChunkyPNG::Image::METADATA_COMPRESSION_TRESHOLD
+    def metadata_chunks
+      metadata.map do |key, value|
+        if value.length >= METADATA_COMPRESSION_TRESHOLD
+          ChunkyPNG::Chunk::CompressedText.new(key, value)
+        else
+          ChunkyPNG::Chunk::Text.new(key, value)
+        end
+      end
+    end
+    
+    # Encodes the image to a PNG datastream for saving to disk or writing to an IO stream.
+    #
+    # Besides encoding the canvas, it will also encode the metadata fields to text chunks.
+    #
+    # @param [Hash] constraints The constraints to use when encoding the canvas.
+    # @return [ChunkyPNG::Datastream] The datastream that contains this image.
+    # @see ChunkyPNG::Canvas::PNGEncoding#to_datastream
+    # @see #metadata_chunks
+    def to_datastream(constraints = {})
+      ds = super(constraints)
+      ds.other_chunks += metadata_chunks
+      return ds
+    end
+    
+    # Reads a ChunkyPNG::Image instance from a data stream.
+    #
+    # Besides decoding the canvas, this will also read the metadata fields
+    # from the datastream.
+    #
+    # @param [ChunkyPNG::Datastream] The datastream to read from.
+    def self.from_datastream(ds)
+      image = super(ds)
+      image.metadata = ds.metadata
+      return image
+    end
+  end
+end

data/vendor/chunky_png/lib/chunky_png/palette.rb

@@ -0,0 +1,209 @@
+module ChunkyPNG
+
+  # A palette describes the set of colors that is being used for an image.
+  #
+  # A PNG image can contain an explicit palette which defines the colors of
+  # that image, but can also use an implicit palette, e.g. all truecolor
+  # colors or all grayscale colors.
+  #
+  # This palette supports decoding colors from a palette if an explicit
+  # palette is provided in a PNG datastream, and it supports encoding colors
+  # to an explicit palette (stores as PLTE & tRNS chunks in a PNG file).
+  #
+  # @see ChunkyPNG::Color
+  class Palette < SortedSet
+
+    # Builds a new palette given a set (Enumerable instance) of colors.
+    #
+    # @param [Enumerable<Integer>] enum The set of colors to include in this palette.
+    #   This Enumerable can contains duplicates.
+    # @param [Array] decoding_map An array of colors in the exact order at which
+    #   they appeared in the palette chunk, so that this array can be used for decoding.
+    def initialize(enum, decoding_map = nil)
+      super(enum)
+      @decoding_map = decoding_map if decoding_map
+    end
+
+    # Builds a palette instance from a PLTE chunk and optionally a tRNS chunk
+    # from a PNG datastream.
+    #
+    # This method will cerate a palette that is suitable for decoding an image.
+    #
+    # @param [ChunkyPNG::Chunk::Palette] The palette chunk to load from
+    # @param [ChunkyPNG::Chunk::Transparency, nil] The optional transparency chunk.
+    # @return [ChunkyPNG::Palette] The loaded palette instance.
+    # @see ChunkyPNG::Palette#can_decode?
+    def self.from_chunks(palette_chunk, transparency_chunk = nil)
+      return nil if palette_chunk.nil?
+
+      decoding_map = []
+      index = 0
+
+      palatte_bytes = palette_chunk.content.unpack('C*')
+      if transparency_chunk
+        alpha_channel = transparency_chunk.content.unpack('C*')
+      else
+        alpha_channel = []
+      end
+
+      index = 0
+      palatte_bytes.each_slice(3) do |bytes|
+        bytes << alpha_channel.fetch(index, ChunkyPNG::Color::MAX)
+        decoding_map << ChunkyPNG::Color.rgba(*bytes)
+        index += 1
+      end
+
+      self.new(decoding_map, decoding_map)
+    end
+
+    # Builds a palette instance from a given canvas.
+    # @param [ChunkyPNG::Canvas] canvas The canvas to create a palette for.
+    # @return [ChunkyPNG::Palette] The palette instance.
+    def self.from_canvas(canvas)
+      self.new(canvas.pixels)
+    end
+
+    # Builds a palette instance from a given set of pixels.
+    # @param [Enumerable<Integer>] pixels An enumeration of pixels to create a palette for
+    # @return [ChunkyPNG::Palette] The palette instance.
+    def self.from_pixels(pixels)
+      self.new(pixels)
+    end
+
+    # Checks whether the size of this palette is suitable for indexed storage.
+    # @return [true, false] True if the number of colors in this palette is at most 256.
+    def indexable?
+      size <= 256
+    end
+
+    # Check whether this palette only contains opaque colors.
+    # @return [true, false] True if all colors in this palette are opaque.
+    # @see ChunkyPNG::Color#opaque?
+    def opaque?
+      all? { |color| Color.opaque?(color) }
+    end
+
+    # Check whether this palette only contains grayscale colors.
+    # @return [true, false] True if all colors in this palette are grayscale teints.
+    # @see ChunkyPNG::Color#grayscale??
+    def grayscale?
+      all? { |color| Color.grayscale?(color) }
+    end
+
+    # Check whether this palette only contains bacl and white.
+    # @return [true, false] True if all colors in this palette are grayscale teints.
+    # @see ChunkyPNG::Color#grayscale??
+    def black_and_white?
+      entries == [ChunkyPNG::Color::BLACK, ChunkyPNG::Color::WHITE]
+    end
+    
+    # Returns a palette with all the opaque variants of the colors in this palette.
+    # @return [ChunkyPNG::Palette] A new Palette instance with only opaque colors.
+    # @see ChunkyPNG::Color#opaque!
+    def opaque_palette
+      self.class.new(map { |c| ChunkyPNG::Color.opaque!(c) })
+    end
+
+    # Checks whether this palette is suitable for decoding an image from a datastream.
+    #
+    # This requires that the positions of the colors in the original palette chunk is known,
+    # which is stored as an array in the +@decoding_map+ instance variable.
+    #
+    # @return [true, false] True if a decoding map was built when this palette was loaded.
+    def can_decode?
+      !@decoding_map.nil?
+    end
+
+    # Checks whether this palette is suitable for encoding an image from to datastream.
+    #
+    # This requires that the position of the color in the future palette chunk is known,
+    # which is stored as a hash in the +@encoding_map+ instance variable.
+    #
+    # @return [true, false] True if a encoding map was built when this palette was loaded.
+    def can_encode?
+      !@encoding_map.nil?
+    end
+
+    # Returns a color, given the position in the original palette chunk.
+    # @param [Integer] index The 0-based position of the color in the palette.
+    # @return [ChunkyPNG::Color] The color that is stored in the palette under the given index
+    # @see ChunkyPNG::Palette#can_decode?
+    def [](index)
+      @decoding_map[index]
+    end
+
+    # Returns the position of a color in the palette
+    # @param [ChunkyPNG::Color] color The color for which to look up the index.
+    # @return [Integer] The 0-based position of the color in the palette.
+    # @see ChunkyPNG::Palette#can_encode?
+    def index(color)
+      color.nil? ? 0 : @encoding_map[color]
+    end
+
+    # Creates a tRNS chunk that corresponds with this palette to store the
+    # alpha channel of all colors.
+    #
+    # Note that this chunk can be left out of every color in the palette is
+    # opaque, and the image is encoded using indexed colors.
+    #
+    # @return [ChunkyPNG::Chunk::Transparency] The tRNS chunk.
+    def to_trns_chunk
+      ChunkyPNG::Chunk::Transparency.new('tRNS', map { |c| ChunkyPNG::Color.a(c) }.pack('C*'))
+    end
+
+    # Creates a PLTE chunk that corresponds with this palette to store the
+    # r, g and b channels of all colors.
+    #
+    # Note that a PLTE chunk should only be included if the image is
+    # encoded using index colors. After this chunk has been built, the
+    # palette becomes suitable for encoding an image.
+    #
+    # @return [ChunkyPNG::Chunk::Palette] The PLTE chunk.
+    # @see ChunkyPNG::Palette#can_encode?
+    def to_plte_chunk
+      @encoding_map = {}
+      colors        = []
+
+      each_with_index do |color, index|
+        @encoding_map[color] = index
+        colors += ChunkyPNG::Color.to_truecolor_bytes(color)
+      end
+
+      ChunkyPNG::Chunk::Palette.new('PLTE', colors.pack('C*'))
+    end
+
+    # Determines the most suitable colormode for this palette.
+    # @return [Integer] The colormode which would create the smallest possible
+    #    file for images that use this exact palette.
+    def best_color_settings
+      if black_and_white?
+        [ChunkyPNG::COLOR_GRAYSCALE, 1]
+      elsif grayscale?
+        if opaque?
+          [ChunkyPNG::COLOR_GRAYSCALE, 8]
+        else
+          [ChunkyPNG::COLOR_GRAYSCALE_ALPHA, 8]
+        end
+      elsif indexable?
+        [ChunkyPNG::COLOR_INDEXED, determine_bit_depth]
+      elsif opaque?
+        [ChunkyPNG::COLOR_TRUECOLOR, 8]
+      else
+        [ChunkyPNG::COLOR_TRUECOLOR_ALPHA, 8]
+      end
+    end
+    
+    # Determines the minimal bit depth required for an indexed image
+    # @return [Integer] Number of bits per pixel, i.e. 1, 2, 4 or 8, or nil if this
+    #    image cannot be saved as an indexed image.
+    def determine_bit_depth
+      case size
+        when 1..2; 1
+        when 3..4; 2
+        when 5..16; 4
+        when 17..256; 8
+        else nil
+      end
+    end
+  end
+end