bench9000 0.1

data/vendor/chunky_png/benchmarks/encoding_benchmark.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'benchmark'
+require 'chunky_png'
+
+image = ChunkyPNG::Image.new(240, 180, ChunkyPNG::Color::TRANSPARENT)
+
+# set some random pixels
+image[10, 20] = ChunkyPNG::Color.rgba(255,   0,   0, 255)
+image[50, 87] = ChunkyPNG::Color.rgba(  0, 255,   0, 255)
+image[33, 99] = ChunkyPNG::Color.rgba(  0,   0, 255, 255)
+
+n = (ENV['N'] || '5').to_i
+
+puts "---------------------------------------------"
+puts "ChunkyPNG (#{ChunkyPNG::VERSION}) encoding benchmark (n=#{n})"
+puts "---------------------------------------------"
+puts
+
+Benchmark.bmbm do |x|
+  x.report('Autodetect (indexed)')  { n.times { image.to_blob } }
+
+  # Presets
+  x.report(':no_compression')    { n.times { image.to_blob(:no_compression) } }
+  x.report(':fast_rgba')         { n.times { image.to_blob(:fast_rgba) } }
+  x.report(':fast_rgb')          { n.times { image.to_blob(:fast_rgb) } }
+  x.report(':good_compression')  { n.times { image.to_blob(:good_compression) } }
+  x.report(':best_compression')  { n.times { image.to_blob(:best_compression) } }
+  
+  # Some options
+  x.report(':rgb')        { n.times { image.to_blob(:color_mode => ChunkyPNG::COLOR_TRUECOLOR) } }
+  x.report(':rgba')       { n.times { image.to_blob(:color_mode => ChunkyPNG::COLOR_TRUECOLOR_ALPHA) } }
+  x.report(':indexed')    { n.times { image.to_blob(:color_mode => ChunkyPNG::COLOR_INDEXED) } }
+  x.report(':interlaced') { n.times { image.to_blob(:interlaced => true) } }
+  
+  # Exports
+  x.report('to RGBA pixelstream') { n.times { image.to_rgba_stream } }
+  x.report('to RGB pixelstream')  { n.times { image.to_rgb_stream } }
+end

data/vendor/chunky_png/benchmarks/filesize_benchmark.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'benchmark'
+require 'chunky_png'
+
+files = ['pixelstream_reference.png', 'operations.png', 'clock_stubbed.png']
+
+def encode_png(image, constraints = {})
+  filesize = nil
+  time = Benchmark.realtime { filesize = image.to_blob(constraints).bytesize }
+  [filesize, time]
+end
+
+files.each do |file|
+  filename = File.join(File.dirname(__FILE__), '..', 'spec', 'resources', file)
+  image = ChunkyPNG::Canvas.from_file(filename)
+
+  puts "#{file}: #{image.width}x#{image.height} - #{image.palette.size} colors"
+  puts "------------------------------------------------"
+  puts "<default>         : %8d bytes in %0.4fs" % encode_png(image)
+  puts ":no_compression   : %8d bytes in %0.4fs" % encode_png(image, :no_compression)
+  puts ":fast_rgba        : %8d bytes in %0.4fs" % encode_png(image, :fast_rgba)
+  puts ":fast_rgb         : %8d bytes in %0.4fs" % encode_png(image, :fast_rgb)
+  puts ":good_compression : %8d bytes in %0.4fs" % encode_png(image, :good_compression)
+  puts ":best_compression : %8d bytes in %0.4fs" % encode_png(image, :best_compression)
+  puts
+end

data/vendor/chunky_png/chunky_png.gemspec

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*-
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'chunky_png/version'
+
+Gem::Specification.new do |s|
+  s.name    = 'chunky_png'
+
+  # Do not change the version and date fields by hand. This will be done
+  # automatically by the gem release script.
+  s.version = ChunkyPNG::VERSION
+
+  s.summary     = "Pure ruby library for read/write, chunk-level access to PNG files"
+  s.description = <<-EOT
+    This pure Ruby library can read and write PNG images without depending on an external 
+    image library, like RMagick. It tries to be memory efficient and reasonably fast.
+    
+    It supports reading and writing all PNG variants that are defined in the specification, 
+    with one limitation: only 8-bit color depth is supported. It supports all transparency, 
+    interlacing and filtering options the PNG specifications allows. It can also read and 
+    write textual metadata from PNG files. Low-level read/write access to PNG chunks is
+    also possible.
+    
+    This library supports simple drawing on the image canvas and simple operations like
+    alpha composition and cropping. Finally, it can import from and export to RMagick for 
+    interoperability.
+    
+    Also, have a look at OilyPNG at http://github.com/wvanbergen/oily_png. OilyPNG is a 
+    drop in mixin module that implements some of the ChunkyPNG algorithms in C, which 
+    provides a massive speed boost to encoding and decoding.
+  EOT
+
+  s.authors  = ['Willem van Bergen']
+  s.email    = ['willem@railsdoctors.com']
+  s.homepage = 'http://wiki.github.com/wvanbergen/chunky_png'
+  s.license  = 'MIT'
+
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rspec', '~> 2.2')
+
+  s.rdoc_options << '--title' << s.name << '--main' << 'README.rdoc' << '--line-numbers' << '--inline-source'
+  s.extra_rdoc_files = ['README.rdoc', 'BENCHMARKS.rdoc']
+
+  s.files = `git ls-files`.split($/)
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+end

data/vendor/chunky_png/lib/chunky_png.rb

@@ -0,0 +1,160 @@
+# Basic requirements from standard library
+require 'set'
+require 'zlib'
+require 'stringio'
+require 'enumerator'
+
+# ChunkyPNG - the pure ruby library to access PNG files.
+#
+# The ChunkyPNG module defines some constants that are used in the
+# PNG specification, specifies some exception classes, and serves as 
+# a namespace for all the other modules and classes in this library.
+#
+# {ChunkyPNG::Image}::      class to represent PNG images, including metadata.
+# {ChunkyPNG::Canvas}::     class to represent the image's canvas.
+# {ChunkyPNG::Color}::      module to work with color values.
+# {ChunkyPNG::Palette}::    represents the palette of colors used on a {ChunkyPNG::Canvas}.
+# {ChunkyPNG::Datastream}:: represents the internal structure of a PNG {ChunkyPNG::Image}.
+# {ChunkyPNG::Color}::      represents one chunk of data within a {ChunkyPNG::Datastream}.
+# {ChunkyPNG::Point}::      geometry helper class representing a 2-dimensional point.
+# {ChunkyPNG::Dimension}::  geometry helper class representing a dimension (i.e. width x height).
+# {ChunkyPNG::Vector}::     geometry helper class representing a series of points.
+#
+# @author Willem van Bergen
+module ChunkyPNG
+
+  ###################################################
+  # PNG international standard defined constants
+  ###################################################
+
+  # Indicates that the PNG image uses grayscale colors, i.e. only a 
+  # single teint channel.
+  # @private
+  COLOR_GRAYSCALE       = 0
+  
+  # Indicates that the PNG image uses true color, composed of a red
+  # green and blue channel.
+  # @private
+  COLOR_TRUECOLOR       = 2
+  
+  # Indicates that the PNG image uses indexed colors, where the values
+  # point to colors defined on a palette.
+  # @private
+  COLOR_INDEXED         = 3
+  
+  # Indicates that the PNG image uses grayscale colors with opacity, i.e.
+  # a teint channel with an alpha channel.
+  # @private
+  COLOR_GRAYSCALE_ALPHA = 4
+  
+  # Indicates that the PNG image uses true color with opacity, composed of 
+  # a red, green and blue channel, and an alpha value.
+  # @private
+  COLOR_TRUECOLOR_ALPHA = 6
+
+  # Indicates that the PNG specification's default compression
+  # method is used (Zlib/Deflate)
+  # @private
+  COMPRESSION_DEFAULT   = 0
+
+  # Indicates that the image does not use interlacing.
+  # @private
+  INTERLACING_NONE      = 0
+  
+  # Indicates that the image uses Adam7 interlacing.
+  # @private  
+  INTERLACING_ADAM7     = 1
+
+  ### Filter method constants
+
+  # Indicates that the PNG specification's default filtering are
+  # being used in the image.
+  # @private
+  FILTERING_DEFAULT     = 0
+
+  # Indicates that no filtering is used for the scanline.
+  # @private
+  FILTER_NONE           = 0
+  
+  # Indicates that SUB filtering is used for the scanline.
+  # @private
+  FILTER_SUB            = 1
+  
+  # Indicates that UP filtering is used for the scanline.
+  # @private
+  FILTER_UP             = 2
+  
+  # Indicates that AVERAGE filtering is used for the scanline.
+  # @private
+  FILTER_AVERAGE        = 3
+  
+  # Indicates that PAETH filtering is used for the scanline.
+  # @private
+  FILTER_PAETH          = 4
+
+  ###################################################
+  # ChunkyPNG exception classes
+  ###################################################
+
+  # Default exception class for ChunkyPNG
+  class Exception < ::StandardError
+  end
+
+  # Exception that is raised for an unsupported PNG image.
+  class NotSupported < ChunkyPNG::Exception
+  end
+
+  # Exception that is raised if the PNG signature is not encountered at the 
+  # beginning of the file.
+  class SignatureMismatch < ChunkyPNG::Exception
+  end
+
+  # Exception that is raised if the CRC check for a block fails
+  class CRCMismatch < ChunkyPNG::Exception
+  end
+
+  # Exception that is raised if an expectation fails.
+  class ExpectationFailed < ChunkyPNG::Exception
+  end
+
+  # Exception that is raised if an expectation fails.
+  class OutOfBounds < ChunkyPNG::ExpectationFailed
+  end
+
+  def self.force_binary(str)
+    str.respond_to?(:force_encoding) ? str.force_encoding('BINARY') : str
+  end
+  
+  # Empty byte array. This basically is an empty string, but with the encoding
+  # set correctly to ASCII-8BIT (binary) in Ruby 1.9.
+  # @return [String] An empty string, with encoding set to binary in Ruby 1.9
+  # @private
+  EMPTY_BYTEARRAY = force_binary("").freeze
+
+  # Null-byte, with the encoding set correctly to ASCII-8BIT (binary) in Ruby 1.9.
+  # @return [String] A binary string, consisting of one NULL-byte. 
+  # @private
+  EXTRA_BYTE = force_binary("\0").freeze
+end
+
+require 'chunky_png/version'
+
+# Ruby 1.8 / 1.9 compatibility
+require 'chunky_png/compatibility'
+
+# PNG file structure
+require 'chunky_png/datastream'
+require 'chunky_png/chunk'
+
+# Colors
+require 'chunky_png/palette'
+require 'chunky_png/color'
+
+# Geometry
+require 'chunky_png/point'
+require 'chunky_png/vector'
+require 'chunky_png/dimension'
+
+# Canvas / Image classes
+require 'chunky_png/canvas'
+require 'chunky_png/image'

data/vendor/chunky_png/lib/chunky_png/canvas.rb

@@ -0,0 +1,372 @@
+require 'chunky_png/canvas/png_encoding'
+require 'chunky_png/canvas/png_decoding'
+require 'chunky_png/canvas/adam7_interlacing'
+require 'chunky_png/canvas/stream_exporting'
+require 'chunky_png/canvas/stream_importing'
+require 'chunky_png/canvas/data_url_exporting'
+require 'chunky_png/canvas/data_url_importing'
+require 'chunky_png/canvas/operations'
+require 'chunky_png/canvas/drawing'
+require 'chunky_png/canvas/resampling'
+require 'chunky_png/canvas/masking'
+
+module ChunkyPNG
+  # The ChunkyPNG::Canvas class represents a raster image as a matrix of
+  # pixels.
+  #
+  # This class supports loading a Canvas from a PNG datastream, and creating a
+  # {ChunkyPNG::Datastream PNG datastream} based on this matrix. ChunkyPNG
+  # only supports 8-bit color depth, otherwise all of the PNG format's
+  # variations are supported for both reading and writing.
+  #
+  # This class offers per-pixel access to the matrix by using x,y coordinates.
+  # It uses a palette (see {ChunkyPNG::Palette}) to keep track of the
+  # different colors used in this matrix.
+  #
+  # The pixels in the canvas are stored as 4-byte fixnum, representing 32-bit
+  # RGBA colors (8 bit per channel). The module {ChunkyPNG::Color} is provided
+  # to work more easily with these number as color values.
+  #
+  # The module {ChunkyPNG::Canvas::Operations} is imported for operations on
+  # the whole canvas, like cropping and alpha compositing. Simple drawing
+  # functions are imported from the {ChunkyPNG::Canvas::Drawing} module.
+  class Canvas
+    include PNGEncoding
+    extend  PNGDecoding
+    extend  Adam7Interlacing
+
+    include StreamExporting
+    extend  StreamImporting
+
+    include DataUrlExporting
+    extend  DataUrlImporting
+
+    include Operations
+    include Drawing
+    include Resampling
+    include Masking
+
+    # @return [Integer] The number of columns in this canvas
+    attr_reader :width
+
+    # @return [Integer] The number of rows in this canvas
+    attr_reader :height
+
+    # @return [Array<ChunkyPNG::Color>] The list of pixels in this canvas.
+    #   This array always should have +width * height+ elements.
+    attr_reader :pixels
+
+
+    #################################################################
+    # CONSTRUCTORS
+    #################################################################
+
+    # Initializes a new Canvas instance.
+    #
+    # @overload initialize(width, height, background_color)
+    #   @param [Integer] width The width in pixels of this canvas
+    #   @param [Integer] height The height in pixels of this canvas
+    #   @param [Integer, ...] background_color The initial background color of
+    #     this canvas. This can be a color value or any value that
+    #     {ChunkyPNG::Color.parse} can handle.
+    #
+    # @overload initialize(width, height, initial)
+    #   @param [Integer] width The width in pixels of this canvas
+    #   @param [Integer] height The height in pixels of this canvas
+    #   @param [Array<Integer>] initial The initial pizel values. Must be an
+    #     array with <tt>width * height</tt> elements.
+    def initialize(width, height, initial = ChunkyPNG::Color::TRANSPARENT)
+      @width, @height = width, height
+
+      if initial.kind_of?(Array)
+        unless initial.length == width * height
+          raise ArgumentError, "The initial array should have #{width}x#{height} = #{width*height} elements!"
+        end
+        @pixels = initial
+      else
+        @pixels = Array.new(width * height, ChunkyPNG::Color.parse(initial))
+      end
+    end
+
+    # Initializes a new Canvas instances when being cloned.
+    # @param [ChunkyPNG::Canvas] other The canvas to duplicate
+    # @return [void]
+    # @private
+    def initialize_copy(other)
+      @width, @height = other.width, other.height
+      @pixels = other.pixels.dup
+    end
+
+    # Creates a new canvas instance by duplicating another instance.
+    # @param [ChunkyPNG::Canvas] canvas The canvas to duplicate
+    # @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
+    def self.from_canvas(canvas)
+      new(canvas.width, canvas.height, canvas.pixels.dup)
+    end
+
+
+    #################################################################
+    # PROPERTIES
+    #################################################################
+
+    # Returns the dimension (width x height) for this canvas.
+    # @return [ChunkyPNG::Dimension] A dimension instance with the width and
+    #   height set for this canvas.
+    def dimension
+      ChunkyPNG::Dimension.new(width, height)
+    end
+
+    # Returns the area of this canvas in number of pixels.
+    # @return [Integer] The number of pixels in this canvas
+    def area
+      pixels.length
+    end
+
+    # Replaces a single pixel in this canvas.
+    # @param [Integer] x The x-coordinate of the pixel (column)
+    # @param [Integer] y The y-coordinate of the pixel (row)
+    # @param [Integer] color The new color for the provided coordinates.
+    # @return [Integer] The new color value for this pixel, i.e.
+    #   <tt>color</tt>.
+    # @raise [ChunkyPNG::OutOfBounds] when the coordinates are outside of the
+    #   image's dimensions.
+    # @see #set_pixel
+    def []=(x, y, color)
+      assert_xy!(x, y)
+      @pixels[y * width + x] = ChunkyPNG::Color.parse(color)
+    end
+
+    # Replaces a single pixel in this canvas, without bounds checking.
+    #
+    # This method return value and effects are undefined for coordinates
+    # out of bounds of the canvas.
+    #
+    # @param [Integer] x The x-coordinate of the pixel (column)
+    # @param [Integer] y The y-coordinate of the pixel (row)
+    # @param [Integer] pixel The new color for the provided coordinates.
+    # @return [Integer] The new color value for this pixel, i.e.
+    #   <tt>color</tt>.
+    def set_pixel(x, y, color)
+      @pixels[y * width + x] = color
+    end
+
+    # Replaces a single pixel in this canvas, with bounds checking. It will do
+    # noting if the provided coordinates are out of bounds.
+    #
+    # @param [Integer] x The x-coordinate of the pixel (column)
+    # @param [Integer] y The y-coordinate of the pixel (row)
+    # @param [Integer] pixel The new color value for the provided coordinates.
+    # @return [Integer] The new color value for this pixel, i.e.
+    #   <tt>color</tt>, or <tt>nil</tt> if the coordinates are out of bounds.
+    def set_pixel_if_within_bounds(x, y, color)
+      return unless include_xy?(x, y)
+      @pixels[y * width + x] = color
+    end
+
+    # Returns a single pixel's color value from this canvas.
+    # @param [Integer] x The x-coordinate of the pixel (column)
+    # @param [Integer] y The y-coordinate of the pixel (row)
+    # @return [Integer] The current color value at the provided coordinates.
+    # @raise [ChunkyPNG::OutOfBounds] when the coordinates are outside of the
+    #   image's dimensions.
+    # @see #get_pixel
+    def [](x, y)
+      assert_xy!(x, y)
+      @pixels[y * width + x]
+    end
+
+    # Returns a single pixel from this canvas, without checking bounds. The
+    # return value for this method is undefined if the coordinates are out of
+    # bounds.
+    #
+    # @param (see #[])
+    # @return [Integer] The current pixel at the provided coordinates.
+    def get_pixel(x, y)
+      @pixels[y * width + x]
+    end
+
+    # Returns an extracted row as vector of pixels
+    # @param [Integer] y The 0-based row index
+    # @return [Array<Integer>] The vector of pixels in the requested row
+    def row(y)
+      assert_y!(y)
+      pixels.slice(y * width, width)
+    end
+
+    # Returns an extracted column as vector of pixels.
+    # @param [Integer] x The 0-based column index.
+    # @return [Array<Integer>] The vector of pixels in the requested column.
+    def column(x)
+      assert_x!(x)
+      (0...height).inject([]) { |pixels, y| pixels << get_pixel(x, y) }
+    end
+
+    # Replaces a row of pixels on this canvas.
+    # @param [Integer] y The 0-based row index.
+    # @param [Array<Integer>] vector The vector of pixels to replace the row
+    #   with.
+    # @return [void]
+    def replace_row!(y, vector)
+      assert_y!(y) && assert_width!(vector.length)
+      pixels[y * width, width] = vector
+    end
+
+    # Replaces a column of pixels on this canvas.
+    # @param [Integer] x The 0-based column index.
+    # @param [Array<Integer>] vector The vector of pixels to replace the column
+    #   with.
+    # @return [void]
+    def replace_column!(x, vector)
+      assert_x!(x) && assert_height!(vector.length)
+      for y in 0...height do
+        set_pixel(x, y, vector[y])
+      end
+    end
+
+    # Checks whether the given coordinates are in the range of the canvas
+    # @param [ChunkyPNG::Point, Array, Hash, String] point_like The point to
+    #   check.
+    # @return [true, false] True if the x and y coordinates of the point are
+    #   within the limits of this canvas.
+    # @see ChunkyPNG.Point
+    def include_point?(*point_like)
+      dimension.include?(ChunkyPNG::Point(*point_like))
+    end
+
+    alias_method :include?,    :include_point?
+
+    # Checks whether the given x- and y-coordinate are in the range of the
+    # canvas
+    #
+    # @param [Integer] x The x-coordinate of the pixel (column)
+    # @param [Integer] y The y-coordinate of the pixel (row)
+    # @return [true, false] True if the x- and y-coordinate is in the range of
+    #   this canvas.
+    def include_xy?(x, y)
+      y >= 0 && y < height && x >= 0 && x < width
+    end
+
+    # Checks whether the given y-coordinate is in the range of the canvas
+    # @param [Integer] y The y-coordinate of the pixel (row)
+    # @return [true, false] True if the y-coordinate is in the range of this
+    #   canvas.
+    def include_y?(y)
+      y >= 0 && y < height
+    end
+
+    # Checks whether the given x-coordinate is in the range of the canvas
+    # @param [Integer] x The y-coordinate of the pixel (column)
+    # @return [true, false] True if the x-coordinate is in the range of this
+    #   canvas.
+    def include_x?(x)
+      x >= 0 && x < width
+    end
+
+    # Returns the palette used for this canvas.
+    # @return [ChunkyPNG::Palette] A palette which contains all the colors that
+    #   are being used for this image.
+    def palette
+      ChunkyPNG::Palette.from_canvas(self)
+    end
+
+    # Equality check to compare this canvas with other matrices.
+    # @param other The object to compare this Matrix to.
+    # @return [true, false] True if the size and pixel values of the other
+    #   canvas are exactly the same as this canvas's size and pixel values.
+    def eql?(other)
+      other.kind_of?(self.class) && other.pixels == self.pixels &&
+            other.width == self.width && other.height == self.height
+    end
+
+    alias :== :eql?
+
+    #################################################################
+    # EXPORTING
+    #################################################################
+
+    # Creates an ChunkyPNG::Image object from this canvas.
+    # @return [ChunkyPNG::Image] This canvas wrapped in an Image instance.
+    def to_image
+      ChunkyPNG::Image.from_canvas(self)
+    end
+
+    # Alternative implementation of the inspect method.
+    # @return [String] A nicely formatted string representation of this canvas.
+    # @private
+    def inspect
+      inspected = "<#{self.class.name} #{width}x#{height} ["
+      for y in 0...height
+        inspected << "\n\t[" << row(y).map { |p| ChunkyPNG::Color.to_hex(p) }.join(' ') << ']'
+      end
+      inspected << "\n]>"
+    end
+
+    protected
+
+    # Replaces the image, given a new width, new height, and a new pixel array.
+    def replace_canvas!(new_width, new_height, new_pixels)
+      unless new_pixels.length == new_width * new_height
+        raise ArgumentError, "The provided pixel array should have #{new_width * new_height} items"
+      end
+      @width, @height, @pixels = new_width, new_height, new_pixels
+      self
+    end
+
+    # Throws an exception if the x-coordinate is out of bounds.
+    def assert_x!(x)
+      unless include_x?(x)
+        raise ChunkyPNG::OutOfBounds, "Column index #{x} out of bounds!"
+      end
+      true
+    end
+
+    # Throws an exception if the y-coordinate is out of bounds.
+    def assert_y!(y)
+      unless include_y?(y)
+        raise ChunkyPNG::OutOfBounds, "Row index #{y} out of bounds!"
+      end
+      true
+    end
+
+    # Throws an exception if the x- or y-coordinate is out of bounds.
+    def assert_xy!(x, y)
+      unless include_xy?(x, y)
+        raise ChunkyPNG::OutOfBounds, "Coordinates (#{x},#{y}) out of bounds!"
+      end
+      true
+    end
+
+    # Throws an exception if the vector_length does not match this canvas'
+    # height.
+    def assert_height!(vector_length)
+      if height != vector_length
+        raise ChunkyPNG::ExpectationFailed,
+          "The length of the vector (#{vector_length}) does not match the canvas height (#{height})!"
+      end
+      true
+    end
+
+    # Throws an exception if the vector_length does not match this canvas'
+    # width.
+    def assert_width!(vector_length)
+      if width != vector_length
+        raise ChunkyPNG::ExpectationFailed,
+          "The length of the vector (#{vector_length}) does not match the canvas width (#{width})!"
+      end
+      true
+    end
+
+    # Throws an exception if the matrix width and height does not match this canvas' dimensions.
+    def assert_size!(matrix_width, matrix_height)
+      if width  != matrix_width
+        raise ChunkyPNG::ExpectationFailed,
+          'The width of the matrix does not match the canvas width!'
+      end
+      if height != matrix_height
+        raise ChunkyPNG::ExpectationFailed,
+          'The height of the matrix does not match the canvas height!'
+      end
+      true
+    end
+  end
+end