png_canvas 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1e5af04de6e23c5a3ed095860288c711674d18e9
+  data.tar.gz: 332d2b59daa8aa307cdc84ae87aee025a6c4fe1c
+SHA512:
+  metadata.gz: 2d47db813a6c5b02725d89d15d8aabb97ca7d517e0cf07b40bb72109f1ca5b1c20c8c97e787d3cf3fcd0352062b9a8de8dff389daa41dbc02bba5d2b8293559f
+  data.tar.gz: 68a192e2c4a1f52c5704be95feab50bd25f1634ee66cc567369fa0b67c8194480e47bd6a289dd66f7ce58b669a8dd9e22b7557f6ae219c102f2fa41bbf223309

data/.gitignore

@@ -0,0 +1,20 @@
+nbproject
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.DS_Store
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+test.png

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 Daniel Cruz Horts
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+# png_canvas
+
+A pure Ruby reimplementation of Rui Carmo's [pngcanvas](https://github.com/rcarmo/pngcanvas) Python library, featuring text writing and few renames.
+
+
+## Usage
+
+Just add it in your Gemfile:
+
+```ruby
+gem 'png_canvas'
+```
+
+and require it when needed:
+
+```ruby
+require 'png_canvas'
+```
+
+### Rendering an image
+
+You can render the [reference image](https://github.com/rcarmo/pngcanvas/blob/master/reference.png) with:
+
+```ruby
+png = PngCanvas.new(512, 512)
+png.rectangle(0, 0, 512 - 1, 512 - 1)
+
+png.vertical_gradient(1, 1, 512 - 2, 512 - 2, [0xff, 0, 0, 0xff], [0x20, 0, 0xff, 0x80])
+
+png.color = [0, 0, 0, 0xff]
+png.line(0, 0, 512 - 1, 512 - 1)
+png.line(0, 0, 512 / 2, 512 - 1)
+png.line(0, 0, 512 - 1, 512 / 2)
+
+png.copy_rectangle(1, 1, 512 / 2 - 1, 512 / 2 - 1, 1, 512 / 2, png)
+
+png.blend_rectangle(1, 1, 512 / 2 - 1, 512 / 2 - 1, 512 / 2, 0, png)
+png.save 'reference.png'
+```
+
+## Reference
+
+- Constructor parameters: **width, height, bgcolor: _default bgcolor_, color: _default fgcolor_**
+
+Colors are specified as 4 element arrays, each representing red, green, blue and alpha values ranging from 0 to 255.
+
+Default background color is white: [0xff, 0xff, 0xff, 0xff]
+
+Default foreground color is black: [0x00, 0x00, 0x00, 0xff]
+
+### Public instance methods
+
+- **color(color)**: sets the default foreground color for the following points and lines
+- **point(x, y, color = nil)**: draws a point at x, y using the specified color (if any) or default
+- **text(x0, y0, string, color = nil)**: writes the string of text at x0, y0
+- **line(x0, y0, x1, y1)**: draws a single line using default color
+- **polyline(point_array)**: draws lines using default color
+- **vertical_gradient(x0, y0, x1, y1, from_color, to_color)**: draws a rectangular color gradient from from_color to to_color
+- **rectangle(x0, y0, x1, y1)**: draws a rectangle with default color
+- **filled_rectangle(x0, y0, x1, y1)**: draws a filled rectangle with default color
+- **copy_rectangle(x0, y0, x1, y1, dx, dy, destination_png)**: copies rectangle from destination_png to current canvas with dx, dy offset
+- **blend_rectangle(x0, y0, x1, y1, dx, dy, destination_png, alpha = 0xff)**: copies rectangle from destination_png to current canvas using alpha transparency
+- **save(file_path)**: saves the canvas to the file_path
+- **load(file_path)**: loads the PNG file from the file_path for manipulation
+- **dump**: returns the contents of the canvas as binary
+
+## Contribute
+
+- Fork it
+- Write your feature with a test
+- Issue a pull request
+- …
+- Profit!

data/lib/png_canvas.rb

@@ -0,0 +1,419 @@
+# Based on Rui Carmo's PNGCanvas
+# https://taoofmac.com/space/projects/PNGCanvas
+# https://github.com/rcarmo/pngcanvas
+# Reference: http://apidock.com/ruby/Array/pack
+
+require 'zlib'
+
+class PngCanvas
+
+  VERSION = '0.0.1'
+
+  CHARSET = {
+    '0' => [0b01111000, 0b10000100, 0b01111000],
+    '1' => [0b01000100, 0b11111100, 0b00000100],
+    '2' => [0b01000100, 0b10001100, 0b10010100, 0b01100100],
+    '3' => [0b01001000, 0b10000100, 0b10100100, 0b01011000],
+    '4' => [0b00110000, 0b01010000, 0b11111100, 0b00010000],
+    '5' => [0b11101000, 0b10100100, 0b10100100, 0b10011000],
+    '6' => [0b01111000, 0b10010100, 0b10100100, 0b00011000],
+    '7' => [0b10000000, 0b10001100, 0b10110000, 0b11000000],
+    '8' => [0b01011000, 0b10100100, 0b10100100, 0b01011000],
+    '9' => [0b01100000, 0b10010100, 0b10100100, 0b01111000],
+    'A' => [0b01111100, 0b10010000, 0b10010000, 0b01111100],
+    'B' => [0b11111100, 0b10100100, 0b10100100, 0b01011000],
+    'C' => [0b01111000, 0b10000100, 0b10000100, 0b01001000],
+    'D' => [0b11111100, 0b10000100, 0b10000100, 0b01111000],
+    'E' => [0b11111100, 0b10100100, 0b10100100, 0b10000100],
+    'F' => [0b11111100, 0b10100000, 0b10100000, 0b10000000],
+    'G' => [0b01111000, 0b10000100, 0b10010100, 0b01011100],
+    'H' => [0b11111100, 0b00100000, 0b00100000, 0b11111100],
+    'I' => [0b10000100, 0b11111100, 0b10000100],
+    'J' => [0b00001000, 0b00000100, 0b10000100, 0b11111000],
+    'K' => [0b11111100, 0b00100000, 0b01011000, 0b10000100],
+    'L' => [0b11111100, 0b00000100, 0b00000100, 0b00000100],
+    'M' => [0b11111100, 0b01100000, 0b01100000, 0b11111100],
+    'N' => [0b11111100, 0b01100000, 0b00111000, 0b11111100],
+    'O' => [0b01111000, 0b10000100, 0b10000100, 0b01111000],
+    'P' => [0b11111100, 0b10010000, 0b10010000, 0b01100000],
+    'Q' => [0b01111000, 0b10010100, 0b10001100, 0b01111000],
+    'R' => [0b11111100, 0b10010000, 0b10011000, 0b11100100],
+    'S' => [0b01100100, 0b10010100, 0b10010100, 0b10001000],
+    'T' => [0b10000000, 0b10000000, 0b11111100, 0b10000000, 0b10000000],
+    'U' => [0b11111000, 0b00000100, 0b00000100, 0b11111000],
+    'V' => [0b11110000, 0b00001100, 0b00001100, 0b11110000],
+    'W' => [0b11111100, 0b00011000, 0b00011000, 0b11111100],
+    'X' => [0b11001100, 0b00110000, 0b00110000, 0b11001100],
+    'Y' => [0b11000000, 0b00100000, 0b00011100, 0b00100000, 0b11000000],
+    'Z' => [0b10001100, 0b10010100, 0b10100100, 0b11000100],
+    'a' => [0b00011000, 0b00100100, 0b00101000, 0b00111100],
+    'b' => [0b11111100, 0b00100100, 0b00100100, 0b00011000],
+    'c' => [0b00011000, 0b00100100, 0b00100100, 0b00100100],
+    'd' => [0b00011000, 0b00100100, 0b00101000, 0b11111100],
+    'e' => [0b00011000, 0b00101100, 0b00110100, 0b00010100],
+    'f' => [0b00010000, 0b01111100, 0b10010000, 0b01000000],
+    'g' => [0b00010000, 0b00101010, 0b00101010, 0b00111100],
+    'h' => [0b11111100, 0b00100000, 0b00100000, 0b00011100],
+    'i' => [0b00100100, 0b10111100, 0b00000100],
+    'j' => [0b00000100, 0b00000010, 0b10111100],
+    'k' => [0b11111100, 0b00010000, 0b00010000, 0b00101100],
+    'l' => [0b10000100, 0b11111100, 0b00000100],
+    'm' => [0b00111100, 0b00100000, 0b00011000, 0b00100000, 0b00111100],
+    'n' => [0b00111100, 0b00010000, 0b00100000, 0b00011100],
+    'o' => [0b00011000, 0b00100100, 0b00100100, 0b00011000],
+    'p' => [0b00111110, 0b00101000, 0b00101000, 0b00010000],
+    'q' => [0b00010000, 0b00101000, 0b00101000, 0b00111110],
+    'r' => [0b00111100, 0b00010000, 0b00100000, 0b00010000],
+    's' => [0b00010100, 0b00110100, 0b00101100, 0b00101000],
+    't' => [0b00100000, 0b11111000, 0b00100100, 0b00001000],
+    'u' => [0b00111000, 0b00000100, 0b00001000, 0b00111100],
+    'v' => [0b00111000, 0b00000100, 0b00111000],
+    'w' => [0b00111000, 0b00000100, 0b00011100, 0b00000100, 0b00111000],
+    'x' => [0b00100100, 0b00011000, 0b00011000, 0b00100100],
+    'y' => [0b00110000, 0b00001010, 0b00001010, 0b00111100],
+    'z' => [0b00100100, 0b00101100, 0b00110100, 0b00100100],
+    '.' => [0b00001100, 0b00001100, 0b00000000],
+    ',' => [0b00001101, 0b00001110, 0b00000000],
+    ':' => [0b01101100, 0b01101100]
+  }
+
+  attr_accessor :color, :canvas
+
+  def initialize(width, height, bgcolor: [0xff, 0xff, 0xff, 0xff], color: [0, 0, 0, 0xff])
+    @canvas = []
+    @width = width
+    @height = height
+    @color = color
+    height.times { @canvas << [bgcolor] * width }
+  end
+
+  def point(x, y, color = nil)
+    return if x < 0 || y < 0 || x > (@width - 1) || y > (@height - 1)
+    color = @color if color.nil?
+    @canvas[y][x] = blend(@canvas[y][x], color)
+  end
+
+  def text(x0, y0, string, color = nil)
+    string = string.to_s
+    return if string.empty?
+    x = 0
+    string.each_char do |char|
+      x += character(x + x0, y0, char, color)
+    end
+  end
+
+  def vertical_gradient(x0, y0, x1, y1, from_color, to_color)
+    x0, y0, x1, y1 = rectangle_helper(x0, y0, x1, y1)
+    gradient = gradient_list(from_color, to_color, y1 - y0)
+    (x0..x1).each do |x|
+      (y0..y1).each do |y|
+        point(x, y, gradient[y - y0])
+      end
+    end
+  end
+
+  def rectangle(x0, y0, x1, y1)
+    x0, y0, x1, y1 = rectangle_helper(x0, y0, x1, y1)
+    polyline([[x0, y0], [x1, y0], [x1, y1], [x0, y1], [x0, y0]])
+  end
+
+  def filled_rectangle(x0, y0, x1, y1)
+    x0, y0, x1, y1 = rectangle_helper(x0, y0, x1, y1)
+    (x0..x1).each do |x|
+      (y0..y1).each do |y|
+        point(x, y, @color)
+      end
+    end
+  end
+
+  def copy_rectangle(x0, y0, x1, y1, dx, dy, destination_png)
+    x0, y0, x1, y1 = rectangle_helper(x0, y0, x1, y1)
+    (x0..x1).each do |x|
+      (y0..y1).each do |y|
+        destination_png.canvas[dy + y - y0][dx + x - x0] = @canvas[y][x]
+      end
+    end
+  end
+
+  def blend_rectangle(x0, y0, x1, y1, dx, dy, destination_png, alpha = 0xff)
+    x0, y0, x1, y1 = rectangle_helper(x0, y0, x1, y1)
+    (x0..x1).each do |x|
+      (y0..y1).each do |y|
+        rgba = @canvas[y][x] + [alpha]
+        destination_png.point(dx + x - x0, dy + y - y0, rgba)
+      end
+    end
+  end
+
+  # Draw a line using Xiaolin Wu's antialiasing technique
+  def line(x0, y0, x1, y1)
+    # clean params
+    x0, y0, x1, y1 = x0.to_i, y0.to_i, x1.to_i, y1.to_i
+    if y0 > y1
+      y0, y1, x0, x1 = y1, y0, x1, x0
+    end
+    dx = x1 - x0
+    if dx < 0
+      sx = -1
+    else
+      sx = 1
+    end
+    dx *= sx
+    dy = y1 - y0
+
+    # 'easy' cases
+    if dy == 0
+      if sx > 0
+        ordering = :each
+      else
+        ordering = :reverse_each
+        x0, x1 = x1, x0
+      end
+      (x0..x1).send(ordering) { |x| point(x, y0) }
+      return
+    end
+    if dx == 0
+      (y0..y1).each { |y| point(x0, y) }
+      point(x1, y1)
+      return
+    end
+    if dx == dy
+      if sx > 0
+        ordering = :each
+      else
+        ordering = :reverse_each
+        x0, x1 = x1, x0
+      end
+      (x0..x1).send(ordering) do |x|
+        point(x, y0)
+        y0 += 1
+      end
+      return
+    end
+
+    # main loop
+    point(x0, y0)
+    e_acc = 0
+    if dy > dx # vertical displacement
+      e = (dx << 16) / dy
+      (y0..y1).each do |i|
+        e_acc_temp, e_acc = e_acc, (e_acc + e) & 0xffff
+        if e_acc <= e_acc_temp
+          x0 += sx
+        end
+        w = 0xff - (e_acc >> 8)
+        point(x0, y0, intensity(@color, w))
+        y0 += 1
+        point(x0 + sx, y0, intensity(@color, 0xff - w))
+      end
+      point(x1, y1)
+      return
+    end
+
+    # horizontal displacement
+    e = (dy << 16) / dx
+    ordering = sx > 0 ? :each : :reverse_each
+    (x0..x1 - sx).send(ordering) do |i|
+      e_acc_temp, e_acc = e_acc, (e_acc + e) & 0xffff
+      if e_acc <= e_acc_temp
+        y0 += 1
+      end
+      w = 0xff - (e_acc >> 8)
+      point(x0, y0, intensity(@color, w))
+      x0 += sx
+      point(x0, y0 + 1, intensity(@color, 0xff - w))
+    end
+    point(x1, y1)
+  end
+
+  def polyline(point_array)
+    (point_array.size - 1).times do |i|
+      line(
+        point_array[i].first,
+        point_array[i].last,
+        point_array[i + 1].first,
+        point_array[i + 1].last
+      )
+    end
+  end
+
+  def dump
+    raw_list = []
+    @height.times do |y|
+      raw_list << 0.chr # filter type 0 (nil)
+      @width.times do |x|
+        raw_list << @canvas[y][x].pack('C3')
+      end
+    end
+    raw_data = raw_list.join
+
+    # 8-bit image represented as RGB tuples
+    # simple transparency, alpha is pure white
+    [137, 80, 78, 71, 13, 10, 26, 10].pack('C8') +
+      pack_chunk('IHDR', [@width, @height, 8, 2, 0, 0, 0].pack('N2C5')) +
+      pack_chunk('tRNS', [0xff, 0xff, 0xff, 0xff, 0xff, 0xff].pack('C6')) +
+      pack_chunk('IDAT', Zlib::Deflate.deflate(raw_data, 9)) +
+      pack_chunk('IEND', '')
+  end
+
+  def save(file_path)
+    file = File.open file_path, 'wb'
+    file.write dump
+    file.close
+  end
+
+  def load(file_path)
+    file = File.open file_path, 'rb'
+    @canvas = []
+
+    file.read(8) # load png header
+
+    chunks(file) do |tag, data|
+      if tag == 'IHDR'
+        width, height, bitdepth, colortype, compression, filter, interlace = data.unpack('N2C5')
+        @width = width
+        @height = height
+        if [bitdepth, colortype, compression, filter, interlace] != [8, 2, 0, 0, 0]
+          raise 'Unsupported PNG format'
+        end
+      # we ignore tRNS because we use pure white as alpha anyway
+      elsif tag == 'IDAT'
+        raw_data = Zlib::Inflate.inflate(data)
+        prev = nil
+        i = 0
+        @height.times do |y|
+          filtertype = raw_data[i].ord
+          i = i + 1
+          cur = raw_data[i..i + @width * 3].unpack 'C*'
+          rgb = defilter(cur, (y == 0 ?  nil : prev), filtertype)
+          prev = cur
+          i = i + @width * 3
+          row = []
+          j = 0
+          @width.times do |x|
+            pixel = rgb[j..j + 3]
+            row << pixel
+            j = j + 3
+          end
+          @canvas << row
+        end
+      end
+    end
+    file.close
+  end
+
+  private
+
+  def pack_chunk(tag, data)
+    to_check = tag + data
+    [data.size].pack('N') + to_check + [Zlib.crc32(to_check)].pack('N')
+  end
+
+  def rectangle_helper(x0, y0, x1, y1)
+    x0, y0, x1, y1 = x0.to_i, y0.to_i, x1.to_i, y1.to_i
+    if x0 > x1
+      x0, x1 = x1, x0
+    end
+    if y0 > y1
+      y0, y1 = y1, y0
+    end
+    [x0, y0, x1, y1]
+  end
+
+  def defilter(cur, prev, filtertype, bpp = 3)
+    if filtertype == 0 # No filter
+      return cur
+    elsif filtertype == 1 # Sub
+      xp = 0
+      [bpp..cur.size].each do |xc|
+        cur[xc] = (cur[xc] + cur[xp]) % 256
+        xp += 1
+      end
+    elsif filtertype == 2 # Up
+      cur.size.times do |xc|
+        cur[xc] = (cur[xc] + prev[xc]) % 256
+      end
+    elsif filtertype == 3 # Average
+      xp = 0
+      cur.size.times do |xc|
+        cur[xc] = (cur[xc] + (cur[xp] + prev[xc]) / 2) % 256
+        xp += 1
+      end
+    elsif filtertype == 4 # Paeth
+      xp = 0
+      bpp.times do |i|
+        cur[i] = (cur[i] + prev[i]) % 256
+      end
+      [bpp..cur.size].each do |xc|
+        a = cur[xp]
+        b = prev[xc]
+        c = prev[xp]
+        p = a + b - c
+        pa = (p - a).abs
+        pb = (p - b).abs
+        pc = (p - c).abs
+        if pa <= pb && pa <= pc
+          value = a
+        elsif pb <= pc
+          value = b
+        else
+          value = c
+        end
+        cur[xc] = (cur[xc] + value) % 256
+        xp += 1
+      end
+    else
+      raise 'Unrecognized scanline filter type'
+    end
+    cur
+  end
+
+  def chunks(f)
+    until f.eof?
+      length = f.read(4).unpack("N")[0]
+      tag = f.read(4)
+      data = f.read(length)
+
+      crc = f.read(4).unpack("N")[0]
+      raise 'File is corrupted' if Zlib.crc32(tag + data) != crc
+
+      yield [tag, data]
+    end
+  end
+
+  # Alpha-blends two colors, using the alpha given by c2
+  def blend(c1, c2)
+    3.times.map { |i| c1[i] * (0xff - c2[3]) + c2[i] * c2[3] >> 8 }
+  end
+
+  # Calculate a new alpha given a 0—0xff intensity
+  def intensity(c, i)
+    [c[0], c[1], c[2], (c[3] * i) >> 8]
+  end
+
+  # Calculate gradient colors
+  def gradient_list(from, to, steps)
+    delta = 4.times.map { |i| to[i] - from[i] }
+    grad = []
+    (steps + 1).times do |i|
+      grad << 4.times.map { |j| from[j] + delta[j] * i / steps }
+    end
+    grad
+  end
+
+  def character(x0, y0, char, color)
+    x = 0
+    if CHARSET[char]
+      CHARSET[char].each do |column|
+        8.times do |y|
+          y_mask = 2**(y - 7).abs
+          point(x + x0, y + y0, color) if column & y_mask == y_mask
+        end
+        x += 1
+      end
+    else # any unknown character will appear as white space
+      return 4 # whitespace width
+    end
+    x + 1 # returns char width
+  end
+end

data/png_canvas.gemspec

@@ -0,0 +1,20 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'png_canvas'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'png_canvas'
+  gem.version       = PngCanvas::VERSION
+  gem.authors       = ['Daniel Cruz Horts']
+  gem.summary       = %q{A minimalist library to render PNG images using pure Ruby}
+  gem.homepage      = 'https://github.com/dncrht/png_canvas'
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_development_dependency 'rspec', '>= 3'
+  gem.add_development_dependency 'pry-byebug'
+end

data/spec/png_canvas_spec.rb

@@ -0,0 +1,119 @@
+require 'base64'
+
+class String
+  def strip_heredoc
+    indent = scan(/^[ \t]*(?=\S)/).min.size rescue 0
+    gsub(/^[ \t]{#{indent}}/, '')
+  end
+end
+
+describe PngCanvas do
+
+  it 'saves and loads a file successfully' do
+    begin
+      png = PngCanvas.new(4, 4)
+      png.line(0, 0, 4, 4)
+      saved_file = png.dump
+      png.save 'test.png'
+      png.load 'test.png'
+      loaded_file = png.dump
+
+      expect(saved_file).to eq loaded_file
+    ensure
+      FileUtils.rm 'test.png'
+    end
+  end
+
+  it 'draws a diagonal line' do
+    png = PngCanvas.new(4, 4)
+    png.line(0, 0, 4, 4)
+
+    expect(png.dump.size).to eq 100
+    expect(Base64.encode64 png.dump).to eq <<-base64.strip_heredoc
+      iVBORw0KGgoAAAANSUhEUgAAAAQAAAAECAIAAAAmkwkpAAAABnRSTlP/////
+      //+evUsyAAAAGUlEQVR42mNgYGD4DwMgFpwPo8B8JDUMDACkuSPdNWcPMwAA
+      AABJRU5ErkJggg==
+    base64
+  end
+
+  it 'draws a red empty square' do
+    png = PngCanvas.new(128, 64)
+    png.color = [0xff, 0, 0, 0xff]
+    png.rectangle(0, 0, 127, 63)
+
+    expect(png.dump.size).to eq 193
+    expect(Base64.encode64 png.dump).to eq <<-base64.strip_heredoc
+      iVBORw0KGgoAAAANSUhEUgAAAIAAAABACAIAAABdtOgoAAAABnRSTlP/////
+      //+evUsyAAAAdklEQVR42u3RsREAMAwCMfYfOval9AQ0+oMJlJdYcf+jUgAA
+      AAAAAIAAABAAAAIAQAAACAAAAQAgAAAEAIAAABAAAAIAQAAACAAAAQAgAAAE
+      AIAAABAAAAIAQAAACAAAAQAgAAAEAIAAABAAAAIAQAAA6AJYcQuila7hrshi
+      HAAAAABJRU5ErkJggg==
+    base64
+  end
+
+  it 'copies and pastes a rectangle' do
+    png = PngCanvas.new(128, 64)
+    png.color = [0xff, 0, 0, 0xff]
+    png.rectangle(0, 0, 127, 63)
+    png.vertical_gradient(1, 1, 126, 62,[0xff, 0, 0, 0xff], [0x20, 0, 0xff, 0x80])
+    png.copy_rectangle(1, 1, 63, 31, 0, 32, png)
+    png.blend_rectangle(1, 1, 63, 31, 64, 0, png)
+
+    expect(png.dump.size).to eq 745
+    expect(Base64.encode64 png.dump).to eq <<-base64.strip_heredoc
+      iVBORw0KGgoAAAANSUhEUgAAAIAAAABACAIAAABdtOgoAAAABnRSTlP/////
+      //+evUsyAAACnklEQVR42u3ca0/OARjH8duhREXlUEM5FCkUU9JBmcVa1mI0
+      i7VYWBrN0miWlgd6wPa/y12KcppmqUYqRKNWE7JoNWFazaGtsrRVWKzGtV3v
+      wb5m+7yAa/s+/e0yjZtMaGNkf+430QOMTrDi0gA/J1pzfZtky6UBvk+24xqy
+      cuTSAMPWTlxfpzhzaYBBGxeu/qmuXBrgyzQ3rl5bdy4N0GfnwfXZ3otLA/RM
+      9+b6MMOHSwN8dPDl6nL049IA3U7+XO9nBnJpgM5ZQVxvZodyaYC3c8K4XjuH
+      c2mADpdNXG1zI7k0QPu8LVyv5kdzaYBW161cLW47uDTAywUxXM0LY7k0wItF
+      u7ieLo7n0gDP3PdwPfHYx6UBmpbs52pYepBLAzR6JnHVLTvMpQHqvZK5Hnmn
+      cGmAx8uPcj1ccZxLA9SuTOOq8Unn0gAPfE9y3VuVyaUB7q8+xVW95jSXBrjr
+      l8VV6X+GSwNUrT3LVRFgcGmAO+vMXLcCLVwa4HZQLldZcD6XBigPKeAqXV/I
+      pQHKQov++yvw8/SbG66iSQD0Nr1kYzGaBEBv02+El6BJAPQ2vXhzOZoEQG/T
+      r0dUoEkA9Db9WmQ1mgRAb9OvRNWgSQD0Nv1ydC2aBEBv0y9tq0OTAOhteuH2
+      RjQJgN6mX4xpQpMA6G36hZ3P0SQAepteENuCJgHQ2/T83a1oEgC9TT8f144m
+      AdDb9Lz4DjQJgN6m5+59hyYB0Nt0S0InmgRAb9MtB7rRJAB6m34u8ROaBEBv
+      03OSetAkAHqbnnOoF00CoLfp2cn9aBIAvU3PPjKAJgHQ23RzyiCaBEBv082p
+      Q2gSAL1NN46NoEkA9DbdSPuBJgHQ23TjxCiaBEBv0430X2gSAD3vNjLG0f6F
+      7+l0vwER6/0xkn8cOwAAAABJRU5ErkJggg==
+    base64
+  end
+
+  it 'copies and pastes a rectangle wth text' do
+    png = PngCanvas.new(128, 64)
+    png.color = [0xff, 0, 0, 0xff]
+    png.rectangle(0, 0, 127, 63)
+    png.vertical_gradient(1, 1, 126, 62,[0xff, 0, 0, 0xff], [0x20, 0, 0xff, 0x80])
+    png.copy_rectangle(1, 1, 63, 31, 0, 32, png)
+    png.blend_rectangle(1, 1, 63, 31, 64, 0, png)
+    png.color = [0, 0, 0, 0xff]
+    png.text(0, 50, 'this is a 50,12')
+
+    expect(png.dump.size).to eq 919
+    expect(Base64.encode64 png.dump).to eq <<-base64.strip_heredoc
+      iVBORw0KGgoAAAANSUhEUgAAAIAAAABACAIAAABdtOgoAAAABnRSTlP/////
+      //+evUsyAAADTElEQVR42u3ce0yNcRzH8celXMqlXGool0oqFVMoxCxmmcVo
+      FrMYGS3NymgW4w/+YDtJUeQ6zaJGCNGUaXJbNE2Yprm0JaMtt8U057t+e3b2
+      nHOqzR+8TXut/Xp69pxn3uavz2htmob2k8z8/ho9QGs3By4V4Ht3R64vPZy4
+      VICvPZ25WhxcuFSAT46uXB97uXGpAM293bma+nhwqQDv+3pyNTp5cakA75y9
+      ud728+NSARr6+3O9GhDEpQK8HhjM9dIlhEsFqHcN5XoxKIxLBagbHM71dEgE
+      lwrwbOhMridukVwqQK37HK7Hw6K4VICa4fO5Ho2I5lIBqj0WclV5LuFSAR6O
+      jOG6PyqWSwV4MHoZ150xcVwqwF2vlVy3vddwqQCVPvFct8au51IBKnwTuMrH
+      beBSAW76JXHd8E/mUgHKAlK4ro/fwqUClAamcpUEpXGpANeCt3FdmbCDSwW4
+      OnEnV/GkXVwqwOWQ3VwXQ/dwqQCXJu/lKppi4lIBLkxN5zoXlsmlApwPz+Iq
+      mJbNpQIUTs/hOjsjl0sFKIg48t8fgZ+nn5l1Ak0CoLfp+bPz0CQAept+OjIf
+      TQKgt+l5cwvRJAB6m35qXhGaBEBv009GFaNJAPQ2/fiCEjQJgN6mH4suRZMA
+      6G360UXlaBIAvU3PXVyBJgHQ2/TDMZVoEgC9TT+09B6aBEBv03Niq9AkAHqb
+      nr28Gk0CoLfpB1fUoEkA9Db9QFwtmgRAb9OzVj1HkwDobXrm6jo0CVDpE69Z
+      LNQ1q7W61rX9uvZ7M3fN4qvjBxre1vyVubYeSgJU+CZoFgt17Q+t1Q2fa/1i
+      +nX9ovmwf90bM/2A02b596597W3zR30Lbvit4Xqnt3X6BMvP1b9b36mfMxIa
+      zMxX2g84EqAsIEWzWKjrZ5sHzf6WvSu3WT/T3j3WL2b9ELOMxEb5009shJIA
+      pYGp1t9tHvQfNVuL9q7cpn+EvV/ZfBnD/YbzvqQmLgnQPvK2d9D/ZTCcDbp4
+      m+Vj7T3EcKfhus0PkgwbPxBJAMQG3d57pic3o0mAv3+A3sFLpm9qQZMA6G26
+      afNnNAmA3qabUr+hSQD0Nt20tRVNAqC36aa0H2gSAD3vNm1vQ/sX/vd0ul8l
+      RVvzUA6odwAAAABJRU5ErkJggg==
+    base64
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'pry-byebug'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'png_canvas'

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: png_canvas
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Daniel Cruz Horts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- MIT-LICENSE
+- README.md
+- lib/png_canvas.rb
+- png_canvas.gemspec
+- spec/png_canvas_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/dncrht/png_canvas
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A minimalist library to render PNG images using pure Ruby
+test_files:
+- spec/png_canvas_spec.rb
+- spec/spec_helper.rb
+has_rdoc: