png 1.1.0 → 1.2.0

data/lib/png/font.rb

@@ -0,0 +1,73 @@
+# encoding: BINARY
+
+require 'png/reader'
+
+##
+# Implements a simple bitmap font by extracting letters from a PNG.
+
+class PNG::Font
+  LETTERS = (('A'..'Z').to_a +
+             ('a'..'z').to_a +
+             ('0'..'9').to_a + [" "] * 16 +
+             '({[<!@#$%^&*?_+-=;,"/~>]})'.split(//))
+
+  attr_reader :height, :width, :canvas
+
+  def self.default
+    @@default ||= new(File.join(File.dirname(__FILE__), "default_font.png"))
+  end
+
+  def initialize(png_file)
+    @canvas = PNG.load_file png_file
+    @height, @width = canvas.height / 4, canvas.width / 26
+    @cache = {}
+  end
+
+  def coordinates c
+    i = LETTERS.index c
+
+    raise ArgumentError, "Can't find #{c.inspect}" unless i
+
+    x = (i % 26) * width
+    y = (3 - (i / 26)) * height # start from the top (3rd row)
+
+    return x, y, x+width-1, y+height-1
+  end
+
+  def [] c
+    c = c.chr unless String === c
+    x0, y0, x1, y1 = coordinates c
+
+    @cache[c] ||= @canvas.extract(x0, y0, x1, y1)
+  end
+end
+
+class PNG::Canvas
+  ##
+  # Write a string at [x, y] with font, optionally specifying a font,
+  # an alignment of :left, :center, or :right and the style to draw
+  # the annotation (see #composite).
+  #
+  #   require 'png/font'
+
+  def annotate(string, x, y,
+               font = PNG::Font.default, align = :left, style = :overwrite)
+    case align
+    when :left then
+      # do nothing
+    when :center then
+      x -= string.length * font.width / 2
+    when :right then
+      x -= string.length * font.width
+    else
+      raise ArgumentError, "Unknown align: #{align.inspect}"
+    end
+
+    x_offset, width = 0, font.width
+
+    string.split(//).each do |char|
+      self.composite font[char], x + x_offset, y
+      x_offset += width
+    end
+  end
+end

data/lib/png/pie.rb

@@ -1,4 +1,4 @@
-#!/usr/local/bin/ruby -w
+# encoding: BINARY
 
 require 'png'
 

data/lib/png/reader.rb

@@ -0,0 +1,142 @@
+# encoding: BINARY
+
+require 'png'
+require 'enumerator'
+
+class PNG
+  def self.load_file path, metadata_only = false
+    file = File.open(path, 'rb') { |f| f.read }
+    self.load file, metadata_only
+  end
+
+  def self.load png, metadata_only = false
+    png = png.dup
+    signature = png.slice! 0, 8
+    raise ArgumentError, 'Invalid PNG signature' unless signature == SIGNATURE
+
+    ihdr = read_chunk 'IHDR', png
+
+    bit_depth, color_type, width, height = read_IHDR ihdr, metadata_only
+
+    return [width, height, bit_depth] if metadata_only
+
+    canvas = PNG::Canvas.new width, height
+
+    type = png.slice(4, 4).unpack('a4').first
+    read_chunk type, png if type == 'iCCP' # Ignore color profile
+
+    read_IDAT read_chunk('IDAT', png), bit_depth, color_type, canvas
+    read_chunk 'IEND', png
+
+    canvas
+  end
+
+  def self.read_chunk expected_type, png
+    size, type = png.slice!(0, 8).unpack 'Na4'
+    data, crc = png.slice!(0, size + 4).unpack "a#{size}N"
+
+    check_crc type, data, crc
+
+    raise ArgumentError, "Expected #{expected_type} chunk, not #{type}" unless
+      type == expected_type
+
+    return data
+  end
+
+  def self.check_crc type, data, crc
+    return true if (type + data).png_crc == crc
+    raise ArgumentError, "Invalid CRC encountered in #{type} chunk"
+  end
+
+  def self.read_IHDR data, metadata_only = false
+    width, height, bit_depth, color_type, *rest = data.unpack 'N2C5'
+
+    unless metadata_only then
+      raise ArgumentError, "Wrong bit depth: #{bit_depth}" unless
+        bit_depth == 8
+      raise ArgumentError, "Wrong color type: #{color_type}" unless
+        color_type == RGBA or color_type = RGB
+      raise ArgumentError, "Unsupported options: #{rest.inspect}" unless
+        rest == [0, 0, 0]
+    end
+
+    return bit_depth, color_type, width, height
+  end
+
+  def self.read_IDAT data, bit_depth, color_type, canvas
+    data = Zlib::Inflate.inflate(data).unpack 'C*'
+
+    pixel_size = color_type == RGBA ? 4 : 3
+
+    height = canvas.height
+    scanline_length = pixel_size * canvas.width + 1 # for filter
+
+    row = canvas.height - 1
+    until data.empty? do
+      row_data = data.slice! 0, scanline_length
+
+      filter = row_data.shift
+      case filter
+      when NONE then
+      when SUB then
+        row_data.each_with_index do |byte, index|
+          left = index < pixel_size ? 0 : row_data[index - pixel_size]
+          row_data[index] = (byte + left) % 256
+        end
+      when UP then
+        row_data.each_with_index do |byte, index|
+          col = index / pixel_size
+          upper = row == 0 ? 0 : canvas[col, row + 1].values[index % pixel_size]
+          row_data[index] = (upper + byte) % 256
+        end
+      when AVG then
+        row_data.each_with_index do |byte, index|
+          col = index / pixel_size
+          upper = row == 0 ? 0 : canvas[col, row + 1].values[index % pixel_size]
+          left = index < pixel_size ? 0 : row_data[index - pixel_size]
+
+          row_data[index] = (byte + ((left + upper)/2).floor) % 256
+        end
+      when PAETH then
+        left = upper = upper_left = nil
+        row_data.each_with_index do |byte, index|
+          col = index / pixel_size
+
+          left = index < pixel_size ? 0 : row_data[index - pixel_size]
+          if row == height then
+            upper = upper_left = 0
+          else
+            upper = canvas[col, row + 1].values[index % pixel_size]
+            upper_left = col == 0 ? 0 :
+              canvas[col - 1, row + 1].values[index % pixel_size]
+          end
+
+          paeth = paeth left, upper, upper_left
+          row_data[index] = (byte + paeth) % 256
+        end
+      else
+        raise ArgumentError, "invalid filter algorithm #{filter}"
+      end
+
+      col = 0
+      row_data.each_slice pixel_size do |slice|
+        slice << 0xFF if pixel_size == 3
+        canvas[col, row] = PNG::Color.new(*slice)
+        col += 1
+      end
+
+      row -= 1
+    end
+  end
+
+  def self.paeth a, b, c # left, above, upper left
+    p = a + b - c
+    pa = (p - a).abs
+    pb = (p - b).abs
+    pc = (p - c).abs
+
+    return a if pa <= pb && pa <= pc
+    return b if pb <= pc
+    c
+  end
+end

data/test/test_png.rb

@@ -1,43 +1,37 @@
-require 'test/unit'
+dir = File.expand_path "~/.ruby_inline"
+if test ?d, dir then
+  require 'fileutils'
+  puts "nuking #{dir}"
+  # force removal, Windoze is bitching at me, something to hunt later...
+  FileUtils.rm_r dir, :force => true
+end
+
+require 'minitest/autorun'
 require 'rubygems'
 require 'png'
+require 'png/reader'
 require 'png/pie'
 
-class TestPng < Test::Unit::TestCase
-
+class TestPng < MiniTest::Unit::TestCase
   def setup
     @canvas = PNG::Canvas.new 5, 10, PNG::Color::White
     @png = PNG.new @canvas
 
-    @IHDR_length = "\000\000\000\r"
-    @IHDR_crc = "\2152\317\275"
-    @IHDR_crc_value = @IHDR_crc.unpack('N').first
-    @IHDR_data = "\000\000\000\n\000\000\000\n\b\006\000\000\000"
-    @IHDR_chunk = "#{@IHDR_length}IHDR#{@IHDR_data}#{@IHDR_crc}"
-
     @blob = <<-EOF.unpack('m*').first
 iVBORw0KGgoAAAANSUhEUgAAAAUAAAAKCAYAAAB8OZQwAAAAD0lEQVR4nGP4
 jwUwDGVBALuJxzlQugpEAAAAAElFTkSuQmCC
     EOF
   end
 
-  def test_class_check_crc
-    assert PNG.check_crc('IHDR', @IHDR_data, @IHDR_crc_value)
-  end
-
-  def test_class_check_crc_exception
-    begin
-      PNG.check_crc('IHDR', @IHDR_data, @IHDR_crc_value + 1)
-    rescue ArgumentError => e
-      assert_equal "Invalid CRC encountered in IHDR chunk", e.message
-    else
-      flunk "exception wasn't raised"
-    end
-  end
-
   def test_class_chunk
     chunk = PNG.chunk 'IHDR', [10, 10, 8, 6, 0, 0, 0 ].pack('N2C5')
-    assert_equal @IHDR_chunk, chunk
+
+    header_crc = "\2152\317\275"
+    header_data = "\000\000\000\n\000\000\000\n\b\006\000\000\000"
+    header_length = "\000\000\000\r"
+    header_chunk = "#{header_length}IHDR#{header_data}#{header_crc}"
+
+    assert_equal header_chunk, chunk
   end
 
   def test_class_chunk_empty
@@ -53,17 +47,104 @@ jwUwDGVBALuJxzlQugpEAAAAAElFTkSuQmCC
   def test_save
     path = "blah.png"
     @png.save(path)
-    assert_equal @blob, File.read(path)
+    file = File.open(path, 'rb') { |f| f.read }
+    assert_equal @blob, file
   ensure
     assert_equal 1, File.unlink(path)
   end
 
-class TestCanvas < Test::Unit::TestCase
+end
+
+class TestCanvas < MiniTest::Unit::TestCase
 
   def setup
     @canvas = PNG::Canvas.new 5, 10, PNG::Color::White
   end
 
+  def test_composite_default
+    canvas1, canvas2 = util_composite_canvases
+
+    canvas1.composite canvas2, 1, 1
+
+    expected = " xxxxxxxx
+                 xxxxxxxx
+                 xx..xxxx
+                 ..xxxxxx
+                          ".gsub(/ /, '')
+
+    assert_equal expected, canvas1.to_s.gsub(/ /, 'x')
+  end
+
+  def test_composite_underlay
+    canvas1, canvas2 = util_composite_canvases
+
+    canvas1.composite canvas2, 1, 1, :add
+
+    expected = " xxxxxxxx
+                 xxxx..xx
+                 xx00xxxx
+                 ..xxxxxx
+                          ".gsub(/ /, '')
+
+    assert_equal expected, canvas1.to_s.gsub(/ /, 'x')
+  end
+
+  def test_composite_overlay
+    canvas1, canvas2 = util_composite_canvases
+
+    canvas1.composite canvas2, 1, 1, :overlay
+
+    expected = " xxxxxxxx
+                 xxxx..xx
+                 xx..xxxx
+                 ..xxxxxx
+                          ".gsub(/ /, '')
+
+    assert_equal expected, canvas1.to_s.gsub(/ /, 'x')
+  end
+
+  def test_composite_blend
+    canvas1, canvas2 = util_composite_canvases
+
+    canvas1.composite canvas2, 1, 1, :blend
+
+    expected = " xxxxxxxx
+                 xxxx..xx
+                 xx,,xxxx
+                 ..xxxxxx
+                          ".gsub(/ /, '')
+
+    assert_equal expected, canvas1.to_s.gsub(/ /, 'x')
+  end
+
+  def test_composite_bad_style
+    canvas1, canvas2 = util_composite_canvases
+
+    assert_raises RuntimeError do
+      canvas1.composite canvas2, 1, 1, :bad
+    end
+  end
+
+  def test_extract
+    canvas1, _ = util_composite_canvases
+
+    expected = " xxxxxxxx
+                 xxxx..xx
+                 xx00xxxx
+                 ..xxxxxx
+                          ".gsub(/ /, '')
+
+    assert_equal expected, canvas1.to_s.gsub(/ /, 'x')
+
+    canvas2 = canvas1.extract(1, 1, 2, 2)
+
+    expected = " xx..
+                 00xx
+                      ".gsub(/ /, '')
+
+    assert_equal expected, canvas2.to_s.gsub(/ /, 'x')
+  end
+
   def test_index
     assert_equal PNG::Color::White, @canvas[1, 2]
     assert_same @canvas[1, 2], @canvas.data[1][2]
@@ -162,7 +243,7 @@ class TestCanvas < Test::Unit::TestCase
   end
 
   def test_point
-    assert_equal PNG::Color.new(0xfe, 0x00, 0xfe, 0xfe),
+    assert_equal PNG::Color.new(0xff, 0x7f, 0xff, 0xff),
                  @canvas.point(0, 0, PNG::Color::Magenta)
     # flunk "this doesn't test ANYTHING"
   end
@@ -171,15 +252,15 @@ class TestCanvas < Test::Unit::TestCase
     @canvas.line 0, 9, 4, 0, PNG::Color::Black
 
     expected = <<-EOF
-..00000000
 ,,00000000
-00,,000000
+,,00000000
+,,,,000000
 00..000000
-00++++0000
+00,,,,0000
 0000..0000
-0000++++00
+0000,,,,00
 000000..00
-000000,,00
+000000,,,,
 00000000..
     EOF
 
@@ -190,25 +271,21 @@ class TestCanvas < Test::Unit::TestCase
     @canvas.line 0, 0, 4, 9, PNG::Color::Black
 
     expected = <<-EOF
-00000000..
 00000000,,
-000000,,00
+00000000,,
+000000,,,,
 000000..00
-0000++++00
+0000,,,,00
 0000..0000
-00++++0000
+00,,,,0000
 00..000000
-00,,000000
+,,,,000000
 ..00000000
     EOF
 
     assert_equal expected, @canvas.to_s
   end
 
-  def util_ascii_art(width, height)
-    (("0" * width * 2) + "\n") * height
-  end
-
   def test_to_s_normal
     @canvas = PNG::Canvas.new 5, 10, PNG::Color::White
     expected = util_ascii_art(5, 10)
@@ -233,31 +310,39 @@ class TestCanvas < Test::Unit::TestCase
     assert_equal expected, @canvas.to_s
   end
 
-#   def test_class_read_chunk
-#     type, data = PNG.read_chunk @IHDR_chunk
+  def util_composite_canvases
+    canvas1 = PNG::Canvas.new 4, 4
+    canvas1[0, 0] = PNG::Color::Black
+    canvas1[1, 1] = PNG::Color::White
+    canvas1[2, 2] = PNG::Color::Black
 
-#     assert_equal 'IHDR', type
-#     assert_equal @IHDR_data, data
-#   end
+    expected = " xxxxxxxx
+                 xxxx..xx
+                 xx00xxxx
+                 ..xxxxxx
+                          ".gsub(/ /, '')
 
-#   def test_class_read_IDAT
-#     canvas = PNG::Canvas.new 10, 10, PNG::Color::White
+    assert_equal expected, canvas1.to_s.gsub(/ /, 'x')
 
-#     data = "x\332c\370O$`\030UH_\205\000#\373\216\200"
 
-#     PNG.read_IDAT data, canvas
+    canvas2 = PNG::Canvas.new 2, 2
+    canvas2[0, 0] = PNG::Color::Black
 
-#     assert_equal @blob, PNG.new(canvas).to_blob
-#   end
+    expected = " xxxx 
+                 ..xx
+                      ".gsub(/ /, '')
 
-#   def test_class_read_IHDR
-#     canvas = PNG.read_IHDR @IHDR_data
-#     assert_equal 10, canvas.width
-#     assert_equal 10, canvas.height
-#   end
+    assert_equal expected, canvas2.to_s.gsub(/ /, 'x')
+
+    return canvas1, canvas2
+  end
+
+  def util_ascii_art(width, height)
+    (("0" * width * 2) + "\n") * height
+  end
 end
 
-class TestPng::TestColor < Test::Unit::TestCase
+class TestPng::TestColor < MiniTest::Unit::TestCase
   def setup
     @color = PNG::Color.new 0x01, 0x02, 0x03, 0x04
   end
@@ -295,10 +380,16 @@ class TestPng::TestColor < Test::Unit::TestCase
   end
 
   def test_blend
-    c1 = @color
-    c2 = PNG::Color.new 0xFF, 0xFE, 0xFD, 0xFC
+#     c1 = @color
+#     c2 = PNG::Color.new 0xFF, 0xFE, 0xFD, 0xFC
+
+#     assert_equal PNG::Color.new(0xFB, 0xFA, 0xF9, 0xF8), c1.blend(c2)
+
+    c1 = PNG::Color::White
+    c2 = PNG::Color::Black
 
-    assert_equal PNG::Color.new(0xfb, 0xfa, 0xf9, 0xf8), c1.blend(c2)
+    assert_equal PNG::Color::Gray, c2.blend(c1)
+    assert_equal PNG::Color::Gray, c1.blend(c2)
   end
 
   def test_intensity
@@ -313,6 +404,21 @@ class TestPng::TestColor < Test::Unit::TestCase
     assert_equal "#<PNG::Color Red>", PNG::Color::Red.inspect
   end
 
+  def test_pipe
+    b = PNG::Color::Black
+    w = PNG::Color::White
+    t = PNG::Color::Background
+
+    # first non-transparent
+    assert_equal b, b | t
+    assert_equal b, t | b
+
+    assert_equal b, b | w
+    assert_equal w, w | b
+
+    assert_equal t, t | t
+  end
+
   def test_to_ascii
     assert_equal '00', PNG::Color::White.to_ascii, "white"
     assert_equal '++', PNG::Color::Yellow.to_ascii, "yellow"
@@ -325,7 +431,7 @@ class TestPng::TestColor < Test::Unit::TestCase
     assert_equal '00', PNG::Color.new(255,255,255,255).to_ascii
     assert_equal '00', PNG::Color.new(255,255,255,192).to_ascii
     assert_equal '++', PNG::Color.new(255,255,255,191).to_ascii
-    assert_equal '++', PNG::Color.new(255,255,255,127).to_ascii
+    assert_equal ',,', PNG::Color.new(255,255,255,127).to_ascii
     assert_equal ',,', PNG::Color.new(255,255,255,126).to_ascii
     assert_equal ',,', PNG::Color.new(255,255,255, 64).to_ascii
     assert_equal '..', PNG::Color.new(255,255,255, 63).to_ascii
@@ -342,18 +448,22 @@ class TestPng::TestColor < Test::Unit::TestCase
     assert_equal '#<PNG::Color:0xXXXXXX>', obj.to_s.sub(/0x[0-9a-f]+/, '0xXXXXXX')
   end
 
+  def test_equals2
+    assert_equal PNG::Color.new(255,255,255,  0), PNG::Color.new(255,255,255,  0)
+  end
+
+  def test_hash
+    a = PNG::Color.new(255,255,255,  0)
+    b = PNG::Color.new(255,255,255,  0)
+    assert_equal a.hash, b.hash
+  end
+
 #   def test_values
 #     raise NotImplementedError, 'Need to write test_values'
 #   end
 end
 
-end
-
-class TestPng::TestPie < Test::Unit::TestCase
-  def setup
-
-  end
-
+class TestPng::TestPie < MiniTest::Unit::TestCase
   def test_pie_chart_odd
     expected =
       ["          ..          ",