bench9000 0.1

data/vendor/chunky_png/lib/chunky_png/point.rb

@@ -0,0 +1,115 @@
+module ChunkyPNG
+  
+  # Factory method to create {ChunkyPNG::Point} instances.
+  # 
+  # This method tries to be as flexible as possible with regards to the given input: besides 
+  # explicit coordinates, this method also accepts arrays, hashes, strings, {ChunkyPNG::Dimension}
+  # instances and anything that responds to <tt>:x</tt> and <tt>:y</tt>.
+  # 
+  # @overload Point(x, y)
+  #   @param [Integer, :to_i] x The x-coordinate
+  #   @param [Integer, :to_i] y The y-coordinate
+  #   @return [ChunkyPNG::Point] The instantiated point.
+  #
+  # @overload Point(array)
+  #   @param [Array<Integer>] array A two element array which represent the x- and y-coordinate.
+  #   @return [ChunkyPNG::Point] The instantiated point.
+  #
+  # @overload Point(hash)
+  #   @param [Hash] array A hash with the <tt>:x</tt> or <tt>'x'</tt> and <tt>:y</tt> or
+  #     <tt>'y'</tt> keys set, which will be used as coordinates.
+  #   @return [ChunkyPNG::Point] The instantiated point.
+  #
+  # @overload Point(string)
+  #   @param [String] string A string that contains the coordinates, e.g. <tt>'0, 4'</tt>,
+  #     <tt>'(0 4)'</tt>, <tt>[0,4}'</tt>, etc.
+  #   @return [ChunkyPNG::Point] The instantiated point.
+  #
+  # @return [ChunkyPNG::Point]
+  # @raise [ArgumentError] if the arguments weren't understood.
+  # @see ChunkyPNG::Point
+  def self.Point(*args)
+    case args.length
+      when 2; ChunkyPNG::Point.new(*args)
+      when 1; case source = args.first
+          when ChunkyPNG::Point; source
+          when ChunkyPNG::Dimension; ChunkyPNG::Point.new(source.width, source.height)
+          when Array; ChunkyPNG::Point.new(source[0], source[1])
+          when Hash; ChunkyPNG::Point.new(source[:x] || source['x'], source[:y] || source['y'])
+          when ChunkyPNG::Point::POINT_REGEXP; ChunkyPNG::Point.new($1.to_i, $2.to_i)
+          else 
+            if source.respond_to?(:x) && source.respond_to?(:y)
+              ChunkyPNG::Point.new(source.x, source.y)
+            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
+  
+  # Simple class that represents a point on a canvas using an x and y coordinate.
+  #
+  # This class implements some basic methods to handle comparison, the splat operator and
+  # bounds checking that make it easier to work with coordinates.
+  #
+  # @see ChunkyPNG.Point
+  class Point
+    
+    # @return [Regexp] The regexp to parse points from a string.
+    # @private
+    POINT_REGEXP = /^[\(\[\{]?(\d+)\s*[,]?\s*(\d+)[\)\]\}]?$/
+
+    # @return [Integer] The x-coordinate of the point.
+    attr_accessor :x
+
+    # @return [Integer] The y-coordinate of the point.
+    attr_accessor :y
+    
+    # Initializes a new point instance.
+    # @param [Integer, :to_i] x The x-coordinate.
+    # @param [Integer, :to_i] y The y-coordinate.
+    def initialize(x, y)
+      @x, @y = x.to_i, y.to_i
+    end
+    
+    # Checks whether 2 points are identical.
+    # @return [true, false] <tt>true</tt> iff the x and y coordinates match
+    def eql?(other)
+      other.x == x && other.y == y
+    end
+    
+    alias_method :==, :eql?
+    
+    # Compares 2 points.
+    #
+    # It will first compare the y coordinate, and it only takes the x-coordinate into
+    # account if the y-coordinates of the points are identical. This way, an array of
+    # points will be sorted into the order in which they would occur in the pixels
+    # array returned by {ChunkyPNG::Canvas#pixels}.
+    #
+    # @param [ChunkyPNG::Point] other The point to compare this point with.
+    # @return [-1, 0, 1] <tt>-1</tt> If this point comes before the other one, <tt>1</tt>
+    #   if after, and <tt>0</tt> if the points are identical.
+    def <=>(other)
+      ((y <=> other.y) == 0) ? x <=> other.x : y <=> other.y
+    end
+    
+    # Converts the point instance to an array.
+    # @return [Array] A 2-element array, i.e. <tt>[x, y]</tt>.
+    def to_a
+      [x, y]
+    end
+    
+    alias_method :to_ary, :to_a
+    
+    # Checks whether the point falls into a dimension
+    # @param [ChunkyPNG::Dimension, ...] dimension_like The dimension of which the bounds 
+    #   should be taken for the check.
+    # @return [true, false] <tt>true</tt> iff the x and y coordinate fall width the width 
+    #   and height of the dimension.
+    def within_bounds?(*dimension_like)
+      ChunkyPNG::Dimension(*dimension_like).include?(self)
+    end
+  end
+end

data/vendor/chunky_png/lib/chunky_png/rmagick.rb

@@ -0,0 +1,43 @@
+require 'RMagick'
+
+module ChunkyPNG
+  
+  # Methods for importing and exporting RMagick image objects.
+  #
+  # By default, this module is disabled because of the dependency on RMagick.
+  # You need to include this module yourself if you want to use it. 
+  #
+  # @example
+  #
+  #    require 'rmagick'
+  #    require 'chunky_png/rmagick'
+  #    
+  #    canvas = ChunkyPNG::Canvas.from_file('filename.png')
+  #    image = ChunkyPNG::RMagick.export(canvas)
+  #    
+  #    # do something with the image using RMagick
+  #    
+  #    updated_canvas = ChunkyPNG::RMagick.import(image)
+  #
+  module RMagick
+    
+    extend self
+    
+    # Imports an RMagick image as Canvas object.
+    # @param [Magick::Image] image The image to import
+    # @return [ChunkyPNG::Canvas] The canvas, constructed from the RMagick image.
+    def import(image)
+      pixels = image.export_pixels_to_str(0, 0, image.columns, image.rows, 'RGBA')
+      ChunkyPNG::Canvas.from_rgba_stream(image.columns, image.rows, pixels)
+    end
+
+    # Exports a Canvas as RMagick image instance.
+    # @param [ChunkyPNG::Canvas] canvas The canvas to export.
+    # @return [Magick::Image] The RMagick image constructed from the Canvas instance.
+    def export(canvas)
+      image = Magick::Image.new(canvas.width, canvas.height)
+      image.import_pixels(0,0, canvas.width, canvas.height, 'RGBA', canvas.pixels.pack('N*'))
+      image
+    end
+  end
+end

data/vendor/chunky_png/lib/chunky_png/vector.rb

@@ -0,0 +1,186 @@
+module ChunkyPNG
+
+  # Factory method for {ChunkyPNG::Vector} instances.
+  #
+  # @overload Vector(x0, y0, x1, y1, x2, y2, ...)
+  #   Creates a vector by parsing two subsequent values in the argument list 
+  #   as x- and y-coordinate of a point.
+  #   @return [ChunkyPNG::Vector] The instantiated vector.
+  # @overload Vector(string)
+  #   Creates a vector by parsing coordinates from the input string.
+  #   @return [ChunkyPNG::Vector] The instantiated vector.
+  # @overload Vector(pointlike, pointlike, pointlike, ...)
+  #   Creates a vector by converting every argument to a point using {ChunkyPNG.Point}.
+  #   @return [ChunkyPNG::Vector] The instantiated vector.
+  #
+  # @return [ChunkyPNG::Vector] The vector created by this factory method.
+  # @raise [ArgumentError] If the given arguments could not be understood as a vector.
+  # @see ChunkyPNG::Vector
+  def self.Vector(*args)
+    
+    return args.first if args.length == 1 && args.first.kind_of?(ChunkyPNG::Vector)
+    
+    if args.length == 1 && args.first.respond_to?(:scan)
+      ChunkyPNG::Vector.new(ChunkyPNG::Vector.multiple_from_string(args.first)) # e.g. ['1,1 2,2 3,3']
+    else
+      ChunkyPNG::Vector.new(ChunkyPNG::Vector.multiple_from_array(args)) # e.g. [[1,1], [2,2], [3,3]] or [1,1,2,2,3,3]
+    end
+  end
+  
+  # Class that represents a vector of points, i.e. a list of {ChunkyPNG::Point} instances.
+  #
+  # Vectors can be created quite flexibly. See the {ChunkyPNG.Vector} factory methods for 
+  # more information on how to construct vectors.
+  class Vector
+    
+    include Enumerable
+    
+    # @return [Array<ChunkyPNG::Point>] The array that holds all the points in this vector.
+    attr_reader :points
+    
+    # Initializes a vector based on a list of Point instances.
+    #
+    # You usually do not want to use this method directly, but call {ChunkyPNG.Vector} instead.
+    #
+    # @param [Array<ChunkyPNG::Point>] points
+    # @see ChunkyPNG.Vector
+    def initialize(points = [])
+      @points = points
+    end
+    
+    # Iterates over all the edges in this vector.
+    #
+    # An edge is a combination of two subsequent points in the vector. Together, they will form
+    # a path from the first point to the last point
+    #
+    # @param [true, false] close Whether to close the path, i.e. return an edge that connects the last
+    #   point in the vector back to the first point.
+    # @return [void]
+    # @raise [ChunkyPNG::ExpectationFailed] if the vector contains less than two points.
+    # @see #edges
+    def each_edge(close = true)
+      raise ChunkyPNG::ExpectationFailed, "Not enough points in this path to draw an edge!" if length < 2
+      points.each_cons(2) { |a, b| yield(a, b) }
+      yield(points.last, points.first) if close
+    end
+    
+    # Returns the point with the given indexof this vector.
+    # @param [Integer] index The 0-based index of the point in this vector.
+    # @param [ChunkyPNG::Point] The point instance.
+    def [](index)
+      points[index]
+    end
+    
+    # Returns an enumerator that will iterate over all the edges in this vector.
+    # @param (see #each_edge)
+    # @return [Enumerator] The enumerator that iterates over the edges.
+    # @raise [ChunkyPNG::ExpectationFailed] if the vector contains less than two points.
+    # @see #each_edge
+    def edges(close = true)
+      to_enum(:each_edge, close)
+    end
+    
+    # Returns the number of points in this vector.
+    # @return [Integer] The length of the points array.
+    def length
+      points.length
+    end
+    
+    # Iterates over all the points in this vector
+    # @yield [ChunkyPNG::Point] The points in the correct order.
+    # @return [void]
+    def each(&block)
+      points.each(&block)
+    end
+    
+    # Comparison between two vectors for quality.
+    # @param [ChunkyPNG::Vector] other The vector to compare with.
+    # @return [true, false] true if the list of points are identical
+    def eql?(other)
+      other.points == points
+    end
+    
+    alias_method :==, :eql?
+
+    # Returns the range in x-coordinates for all the points in this vector.
+    # @return [Range] The (inclusive) range of x-coordinates.
+    def x_range
+      Range.new(*points.map { |p| p.x }.minmax)
+    end
+
+    # Returns the range in y-coordinates for all the points in this vector.
+    # @return [Range] The (inclusive) range of y-coordinates.
+    def y_range
+      Range.new(*points.map { |p| p.y }.minmax)
+    end
+    
+    # Finds the lowest x-coordinate in this vector.
+    # @return [Integer] The lowest x-coordinate of all the points in the vector.
+    def min_x
+      x_range.first
+    end
+    
+    # Finds the highest x-coordinate in this vector.
+    # @return [Integer] The highest x-coordinate of all the points in the vector.
+    def max_x
+      x_range.last
+    end
+
+    # Finds the lowest y-coordinate in this vector.
+    # @return [Integer] The lowest y-coordinate of all the points in the vector.
+    def min_y
+      y_range.first
+    end
+    
+    # Finds the highest y-coordinate in this vector.
+    # @return [Integer] The highest y-coordinate of all the points in the vector.
+    def max_y
+      y_range.last
+    end
+    
+    # Returns the offset from (0,0) of the minimal bounding box of all the
+    # points in this vector
+    # @return [ChunkyPNG::Point] A point that describes the top left corner if a
+    #    minimal bounding box would be drawn around all the points in the vector.
+    def offset
+      ChunkyPNG::Point.new(min_x, min_y)
+    end
+    
+    # Returns the width of the minimal bounding box of all the points in this vector.
+    # @return [Integer] The x-distance between the points that are farthest from each other.
+    def width
+      1 + (max_x - min_x)
+    end
+
+    # Returns the height of the minimal bounding box of all the points in this vector.
+    # @return [Integer] The y-distance between the points that are farthest from each other.
+    def height
+      1 + (max_y - min_y)
+    end
+    
+    # Returns the dimension of the minimal bounding rectangle of the points in this vector.
+    # @return [ChunkyPNG::Dimension] The dimension instance with the width and height 
+    def dimension
+      ChunkyPNG::Dimension.new(width, height)
+    end
+    
+    # @return [Array<ChunkyPNG::Point>] The list of points interpreted from the input array.
+    def self.multiple_from_array(source)
+      return [] if source.empty?
+      if source.first.kind_of?(Numeric) || source.first =~ /^\d+$/
+        raise ArgumentError, "The points array is expected to have an even number of items!" if source.length % 2 != 0
+
+        points = []
+        source.each_slice(2) { |x, y| points << ChunkyPNG::Point.new(x, y) }
+        return points
+      else
+        source.map { |p| ChunkyPNG::Point(p) }
+      end
+    end
+    
+    # @return [Array<ChunkyPNG::Point>] The list of points parsed from the string.
+    def self.multiple_from_string(source_str)
+      multiple_from_array(source_str.scan(/[\(\[\{]?(\d+)\s*[,x]?\s*(\d+)[\)\]\}]?/))
+    end
+  end
+end

data/vendor/chunky_png/lib/chunky_png/version.rb

@@ -0,0 +1,5 @@
+module ChunkyPNG
+  # The current version of ChunkyPNG. 
+  # Set it and commit the change this before running rake release.
+  VERSION = "1.3.0"
+end

data/vendor/chunky_png/spec/chunky_png/canvas/adam7_interlacing_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Canvas::Adam7Interlacing do
+  include ChunkyPNG::Canvas::Adam7Interlacing
+
+  describe '#adam7_pass_sizes' do
+    it "should get the pass sizes for a 8x8 image correctly" do
+      adam7_pass_sizes(8, 8).should == [
+          [1, 1], [1, 1], [2, 1], [2, 2], [4, 2], [4, 4], [8, 4]
+        ]
+    end
+
+    it "should get the pass sizes for a 12x12 image correctly" do
+      adam7_pass_sizes(12, 12).should == [
+          [2, 2], [1, 2], [3, 1], [3, 3], [6, 3], [6, 6], [12, 6]
+        ]
+    end
+
+    it "should get the pass sizes for a 33x47 image correctly" do
+      adam7_pass_sizes(33, 47).should == [
+          [5, 6], [4, 6], [9, 6], [8, 12], [17, 12], [16, 24], [33, 23]
+        ]
+    end
+
+    it "should get the pass sizes for a 1x1 image correctly" do
+      adam7_pass_sizes(1, 1).should == [
+          [1, 1], [0, 1], [1, 0], [0, 1], [1, 0], [0, 1], [1, 0]
+        ]
+    end
+
+    it "should get the pass sizes for a 0x0 image correctly" do
+      adam7_pass_sizes(0, 0).should == [
+          [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]
+        ]
+    end
+
+    it "should always maintain the same amount of pixels in total" do
+      [[8, 8], [12, 12], [33, 47], [1, 1], [0, 0]].each do |(width, height)|
+        pass_sizes = adam7_pass_sizes(width, height)
+        pass_sizes.inject(0) { |sum, (w, h)| sum + (w*h) }.should == width * height
+      end
+    end
+  end
+
+  describe '#adam7_multiplier_offset' do
+    it "should get the multiplier and offset values for pass 1 correctly" do
+      adam7_multiplier_offset(0).should == [3, 0, 3, 0]
+    end
+    
+    it "should get the multiplier and offset values for pass 2 correctly" do
+      adam7_multiplier_offset(1).should == [3, 4, 3, 0]
+    end
+    
+    it "should get the multiplier and offset values for pass 3 correctly" do
+      adam7_multiplier_offset(2).should == [2, 0, 3, 4]
+    end
+    
+    it "should get the multiplier and offset values for pass 4 correctly" do
+      adam7_multiplier_offset(3).should == [2, 2, 2, 0]
+    end
+    
+    it "should get the multiplier and offset values for pass 5 correctly" do
+      adam7_multiplier_offset(4).should == [1, 0, 2, 2]
+    end
+
+    it "should get the multiplier and offset values for pass 6 correctly" do
+      adam7_multiplier_offset(5).should == [1, 1, 1, 0]
+    end
+    
+    it "should get the multiplier and offset values for pass 7 correctly" do
+      adam7_multiplier_offset(6).should == [0, 0, 1, 1]
+    end
+  end
+
+  describe '#adam7_merge_pass' do
+    it "should merge the submatrices correctly" do
+      submatrices = [
+        ChunkyPNG::Canvas.new(1, 1,  168430335), # r = 10
+        ChunkyPNG::Canvas.new(1, 1,  336860415), # r = 20
+        ChunkyPNG::Canvas.new(2, 1,  505290495), # r = 30
+        ChunkyPNG::Canvas.new(2, 2,  677668095), # r = 40
+        ChunkyPNG::Canvas.new(4, 2,  838912255), # r = 50
+        ChunkyPNG::Canvas.new(4, 4, 1023344895), # r = 60
+        ChunkyPNG::Canvas.new(8, 4, 1175063295), # r = 70
+      ]
+      
+      canvas = ChunkyPNG::Image.new(8,8)
+      submatrices.each_with_index { |m, pass| adam7_merge_pass(pass, canvas, m) }
+      canvas.should == reference_image('adam7')
+    end
+  end
+
+  describe '#adam7_extract_pass' do
+    before(:each) { @canvas = reference_canvas('adam7') }
+
+    1.upto(7) do |pass|
+      it "should extract pass #{pass} correctly" do
+        sm = adam7_extract_pass(pass - 1, @canvas)
+        sm.pixels.length.should == sm.width * sm.height
+        sm.pixels.uniq.length.should == 1
+        ChunkyPNG::Color.r(sm[0,0]).should == pass * 10
+      end
+    end
+  end
+
+end