png 1.0.0 → 1.1.0

data/History.txt

@@ -0,0 +1,18 @@
+*** 1.1.0 / 2007-03-26
+
++ 4 major enhancements:
+    + Fixed and incorporated Dominik Barathon's optimizations.
+    + Wrote inline methods for png_crc and png_join. Now about 15x faster overall.
+    + Basic PNG loading.
+    + Reoriented x/y origin to bottom left. This will break things!
++ 3 minor enhancements:
+    + Awesome ascii art patches from Tom Werner: Canvas#inpsect, Canvas#to_s, Color#to_ascii.
+    + Switched to Hoe.
+    + PNG.pie_chart from png/pie.
++ 1 bug fix:
+    + Fixed bug in PNG::Canvas#each.
+
+*** 1.0.0 / 2006-09-31
+
++ Birthday!
+

data/Manifest.txt

@@ -1,5 +1,10 @@
+History.txt
 Manifest.txt
-README
+README.txt
 Rakefile
 example/lines.rb
+example/profile.rb
+example/profile_lines.rb
 lib/png.rb
+lib/png/pie.rb
+test/test_png.rb

data/README.txt

@@ -0,0 +1,65 @@
+= PNG
+
+* http://seattlerb.rubyforge.org/
+
+== DESCRIPTION
+
+PNG is an almost-pure-ruby PNG library. It lets you write a PNG
+without any C libraries.
+
+== FEATURES
+
+* Very simple interface.
+* Outputs simple PNG files with ease.
+* Basic PNG reader as well (someday it might do compositing and the like!).
+* Almost pure ruby, does require a compiler.
+
+== SYNOPSYS
+
+    require 'png'
+    
+    canvas = PNG::Canvas.new 200, 200
+    
+    # Set a point to a color
+    canvas[100, 100] = PNG::Color::Black
+    
+    # draw an anti-aliased line
+    canvas.line 50, 50, 100, 50, PNG::Color::Blue
+    
+    png = PNG.new canvas
+    png.save 'blah.png'
+
+== REQUIREMENTS
+
++ C compiler
++ RubyInline
++ Hoe
+
+== INSTALL
+
++ sudo gem install -y png
+
+== LICENSE
+
+(The MIT License)
+
+Copyright (c) 2006-2007 Ryan Davis, Eric Hodel, Zen Spider Software
+
+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/Rakefile

@@ -1,56 +1,17 @@
-require 'rubygems'
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
+require 'hoe'
+require './lib/png.rb'
 
-$VERBOSE = nil
+Hoe.new 'png', PNG::VERSION do |s|
+  s.rubyforge_name = 'seattlerb'
+  s.author = ['Ryan Davis', 'Eric Hodel']
+  s.email = 'support@zenspider.com'
 
-spec = Gem::Specification.new do |s|
-  s.name = 'png'
-  s.version = '1.0.0'
-  s.summary = 'A pure ruby PNG library'
-  s.description = 'png allows you to write a PNG file without any C libraries.'
-  s.author = 'Ryan Davis'
-  s.email = 'ryand-ruby@zenspider.com'
+  s.summary = 'An almost-pure-ruby PNG library'
+  s.description = s.paragraphs_of('README.txt', 3..7).join("\n\n")
 
-  s.has_rdoc = true
-  s.files = File.read('Manifest.txt').split($/)
-  s.require_path = 'lib'
-end
-
-desc 'Run tests'
-task :default => [ :test ]
-
-Rake::TestTask.new('test') do |t|
-  t.libs << 'test'
-  t.pattern = 'test/test_*.rb'
-  t.verbose = true
-end
-
-desc 'Update Manifest.txt'
-task :update_manifest do
-  sh "find . -type f | sed -e 's%./%%' | egrep -v 'svn|swp|~' | egrep -v '^(doc|pkg)/' | sort > Manifest.txt"
-end
-
-desc 'Generate RDoc'
-Rake::RDocTask.new :rdoc do |rd|
-  rd.rdoc_dir = 'doc'
-  rd.rdoc_files.add 'lib', 'README'
-  rd.main = 'README'
-  rd.options << '-d' if `which dot` =~ /\/dot/
-  rd.options << '-t png'
-end
+  s.changes = s.paragraphs_of('History.txt', 0..1).join("\n\n")
 
-desc 'Build Gem'
-Rake::GemPackageTask.new spec do |pkg|
-  pkg.need_tar = true
+  s.extra_deps << ['RubyInline', '>= 3.5.0']
 end
 
-desc 'Clean up'
-task :clean => [ :clobber_rdoc, :clobber_package ]
-
-desc 'Clean up'
-task :clobber => [ :clean ]
-
 # vim: syntax=Ruby

data/example/lines.rb

@@ -2,7 +2,7 @@
 
 require 'png'
 
-canvas = PNG::Canvas.new 1024, 1024, PNG::Color::Black
+canvas = PNG::Canvas.new 1024, 1024, PNG::Color::White
 
 #canvas.each do |x, y|
 #  case x
@@ -17,9 +17,10 @@ canvas = PNG::Canvas.new 1024, 1024, PNG::Color::Black
 canvas.line  50,  50, 100,  50, PNG::Color::Blue
 canvas.line  50,  50,  50, 100, PNG::Color::Blue
 canvas.line 100,  50, 150, 100, PNG::Color::Blue
-canvas.line 100,  50, 125, 100, PNG::Color::Green # currently wrong
-canvas.line 100,  50, 200,  75, PNG::Color::Green # currently wrong
+canvas.line 100,  50, 125, 100, PNG::Color::Green
+canvas.line 100,  50, 200,  75, PNG::Color::Green
 canvas.line   0, 200, 200,   0, PNG::Color::Black
+canvas.line   0, 200, 150,   0, PNG::Color::Red
 
 png = PNG.new canvas
 png.save 'blah.png'

data/example/profile.rb

@@ -0,0 +1,16 @@
+require 'png'
+
+class PNGProfile
+
+  def draw
+    canvas = PNG::Canvas.new 400, 400
+    png = PNG.new canvas
+    png.to_blob
+  end
+
+end
+
+pp = PNGProfile.new
+
+10.times do pp.draw end
+

data/example/profile_lines.rb

@@ -0,0 +1,37 @@
+require 'png'
+
+class PNGProfileLine
+
+  COLORS = [
+    PNG::Color::Red,
+    PNG::Color::Orange,
+    PNG::Color::Yellow,
+    PNG::Color::Green,
+    PNG::Color::Blue,
+    PNG::Color::Purple,
+  ]
+
+  def draw
+    line = 0
+    canvas = PNG::Canvas.new 100, 100
+
+    0.step 99, 10 do |x|
+      canvas.line x, 0, 99 - x, 99, COLORS[line % 6]
+      line += 1
+    end
+
+    0.step 99, 10 do |y|
+      canvas.line 0, y, 99, y, COLORS[line % 6]
+      line += 1
+    end
+
+    canvas
+  end
+
+end
+
+ppl = PNGProfileLine.new
+
+5.times do ppl.draw end
+#PNG.new(ppl.draw).save 'x.png'
+

data/lib/png.rb

@@ -1,33 +1,56 @@
+begin; require 'rubygems'; rescue LoadError; end
 require 'zlib'
+require 'inline'
 
-class String # :nodoc:
+class String # :nodoc: # ZenTest SKIP
 
   ##
   # Calculates a CRC using the algorithm in the PNG specification.
 
-  def png_crc
-    unless defined? @@crc then
-      @@crc = Array.new(256)
-      256.times do |n|
-        c = n
-        8.times do
-          c = (c & 1 == 1) ? 0xedb88320 ^ (c >> 1) : c >> 1
-        end
-        @@crc[n] = c
-      end
+  inline do |builder|
+    if RUBY_VERSION < "1.8.6" then
+      builder.prefix <<-EOM
+        #define RSTRING_PTR(s) (RSTRING(s)->ptr)
+        #define RSTRING_LEN(s) (RSTRING(s)->len)
+      EOM
     end
 
-    c = 0xffffffff
-    each_byte do |b|
-      c = @@crc[(c^b) & 0xff] ^ (c >> 8)
-    end
-    return c ^ 0xffffffff
+    builder.c <<-EOM
+      unsigned long png_crc() {
+        static unsigned long crc[256];
+        static char crc_table_computed = 0;
+      
+        if (! crc_table_computed) {
+          unsigned long c;
+          int n, k;
+        
+          for (n = 0; n < 256; n++) {
+            c = (unsigned long) n;
+            for (k = 0; k < 8; k++) {
+              c = (c & 1) ? 0xedb88320L ^ (c >> 1) : c >> 1;
+            }
+            crc[n] = c;
+          }
+          crc_table_computed = 1;
+        }
+
+        unsigned long c = 0xffffffff;
+        unsigned len = RSTRING_LEN(self);
+        char * s = StringValuePtr(self);
+        unsigned i;
+
+        for (i = 0; i < len; i++) {
+          c = crc[(c ^ s[i]) & 0xff] ^ (c >> 8);
+        }
+
+        return c ^ 0xffffffff;
+      }
+    EOM
   end
-
 end
 
 ##
-# A pure Ruby Portable Network Graphics (PNG) writer.
+# An almost-pure-ruby Portable Network Graphics (PNG) writer.
 #
 # http://www.libpng.org/pub/png/spec/1.2/
 #
@@ -42,7 +65,7 @@ end
 # = Example
 #
 #   require 'png'
-#   
+#
 #   canvas = PNG::Canvas.new 200, 200
 #   canvas[100, 100] = PNG::Color::Black
 #   canvas.line 50, 50, 100, 50, PNG::Color::Blue
@@ -51,6 +74,46 @@ end
 
 class PNG
 
+  VERSION = '1.1.0'
+  SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10].pack("C*")
+
+  inline do |builder|
+    if RUBY_VERSION < "1.8.6" then
+      builder.prefix <<-EOM
+        #define RARRAY_PTR(s) (RARRAY(s)->ptr)
+        #define RARRAY_LEN(s) (RARRAY(s)->len)
+      EOM
+    end
+
+    # C equivalent of:
+    # @data.map { |row| "\0" + row.map { |p| p.values }.join }.join
+    builder.c <<-EOM
+      VALUE png_join() {
+        int i, j;
+        VALUE data = rb_iv_get(self, "@data");
+        unsigned int data_len = RARRAY_LEN(data);
+        unsigned int row_len = RARRAY_LEN(RARRAY_PTR(data)[0]);
+        unsigned long size = data_len * (1 + (row_len * 4));
+        char * result = malloc(size);
+        unsigned long idx = 0;
+        for (i = 0; i < data_len; i++) {
+          VALUE row = RARRAY_PTR(data)[i];
+          result[idx++] = 0;
+          for (j = 0; j < row_len; j++) {
+            VALUE color = RARRAY_PTR(row)[j];
+            VALUE values = rb_iv_get(color, "@values");
+            char * value = StringValuePtr(values);
+            result[idx++] = value[0];
+            result[idx++] = value[1];
+            result[idx++] = value[2];
+            result[idx++] = value[3];
+          }          
+        }
+        return rb_str_new(result, size);
+      }
+    EOM
+  end
+
   ##
   # Creates a PNG chunk of type +type+ that contains +data+.
 
@@ -58,6 +121,116 @@ class PNG
     [data.size, type, data, (type + data).png_crc].pack("Na*a*N")
   end
 
+  def self.load(png)
+    png = png.dup
+    signature = png.slice! 0, 8
+    raise ArgumentError, 'Invalid PNG signature' unless signature == SIGNATURE
+
+    type, data = read_chunk png
+
+    raise ArgumentError, 'Invalid PNG, no IHDR chunk' unless type == 'IHDR'
+
+    canvas = read_IHDR data
+    type, data = read_chunk png
+    read_IDAT data, canvas
+    type, data = read_chunk png
+    raise 'oh no! IEND not next? crashing and burning!' unless type == 'IEND'
+
+    new canvas
+  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.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
+
+  def self.read_chunk(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
+
+    return type, data
+  end
+
+  def self.read_IDAT(data, canvas)
+    data = Zlib::Inflate.inflate(data).unpack 'C*'
+    scanline_length = 4 * canvas.width + 1 # for filter
+    row = 0
+    until data.empty? do
+      row_data = data.slice! 0, scanline_length
+      filter = row_data.shift
+      case filter
+      when 0 then # None
+      when 1 then # Sub
+        row_data.each_with_index do |byte, index|
+          left = index < 4 ? 0 : row_data[index - 4]
+          row_data[index] = (byte + left) % 256
+          #p [byte, left, row_data[index]]
+        end
+      when 2 then # Up
+        row_data.each_with_index do |byte, index|
+          col = index / 4
+          upper = row == 0 ? 0 : canvas[col, row - 1].values[index % 4]
+          row_data[index] = (upper + byte) % 256
+        end
+      when 3 then # Average
+        row_data.each_with_index do |byte, index|
+          col = index / 4
+          upper = row == 0 ? 0 : canvas[col, row - 1].values[index % 4]
+          left = index < 4 ? 0 : row_data[index - 4]
+
+          row_data[index] = (byte + ((left + upper)/2).floor) % 256
+        end
+      when 4 then # Paeth
+        left = upper = upper_left = nil
+        row_data.each_with_index do |byte, index|
+          col = index / 4
+
+          left = index < 4 ? 0 : row_data[index - 4]
+          if row == 0 then
+            upper = upper_left = 0
+          else
+            upper = canvas[col, row - 1].values[index % 4]
+            upper_left = col == 0 ? 0 :
+                           canvas[col - 1, row - 1].values[index % 4]
+          end
+
+          paeth = paeth left, upper, upper_left
+          row_data[index] = (byte + paeth) % 256
+          #p [byte, paeth, row_data[index]]
+        end
+      else
+        raise ArgumentError, "Invalid filter algorithm #{filter}"
+      end
+
+      col = 0
+      row_data.each_slice 4 do |slice|
+        canvas[col, row] = PNG::Color.new(*slice)
+        col += 1
+      end
+
+      row += 1
+    end
+  end
+
+  def self.read_IHDR(data)
+    width, height, *rest = data.unpack 'N2C5'
+    raise ArgumentError, 'unsupported PNG file' unless rest == [8, 6, 0, 0, 0]
+    return PNG::Canvas.new(height, width)
+  end
+
   ##
   # Creates a new PNG object using +canvas+
 
@@ -72,15 +245,22 @@ class PNG
   # Writes the PNG to +path+.
 
   def save(path)
-    File.open(path, "w") do |f|
-      f.write [137, 80, 78, 71, 13, 10, 26, 10].pack("C*") # PNG signature
-      f.write PNG.chunk('IHDR',
-                        [ @height, @width, @bits, 6, 0, 0, 0 ].pack("N2C5"))
-      # 0 == filter type code "none"
-      data = @data.map { |row| [0] + row.map { |p| p.values } }.flatten
-      f.write PNG.chunk('IDAT', Zlib::Deflate.deflate(data.pack("C*"), 9))
-      f.write PNG.chunk('IEND', '')
-    end
+    File.open path, 'wb' do |f| f.write to_blob end
+  end
+
+  ##
+  # Raw PNG data
+
+  def to_blob
+    blob = []
+
+    blob << SIGNATURE
+    blob << PNG.chunk('IHDR', [@width, @height, @bits, 6, 0, 0, 0 ].pack("N2C5"))
+    # 0 == filter type code "none"
+    data = self.png_join
+    blob << PNG.chunk('IDAT', Zlib::Deflate.deflate(data))
+    blob << PNG.chunk('IEND', '')
+    blob.join
   end
 
   ##
@@ -90,28 +270,42 @@ class PNG
 
     attr_reader :values
 
+    def self.from str, name = nil
+      str = "%08x" % str if Integer === str
+      colors = str.scan(/[\da-f][\da-f]/i).map { |n| n.hex }
+      colors << name
+      self.new(*colors)
+    end
+
     ##
     # Creates a new color with values +red+, +green+, +blue+, and +alpha+.
 
-    def initialize(red, green, blue, alpha)
-      @values = [red, green, blue, alpha]
+    def initialize(red, green, blue, alpha, name = nil)
+      @values = "%c%c%c%c" % [red, green, blue, alpha]
+      @name = name
     end
 
     ##
     # Transparent white
 
-    Background = Color.new 0xFF, 0xFF, 0xFF, 0x00
- 
-    White      = Color.new 0xFF, 0xFF, 0xFF, 0xFF
-    Black      = Color.new 0x00, 0x00, 0x00, 0xFF
-    Gray       = Color.new 0x7F, 0x7F, 0x7F, 0xFF
-
-    Red        = Color.new 0xFF, 0x00, 0x00, 0xFF
-    Orange     = Color.new 0xFF, 0xA5, 0x00, 0xFF
-    Yellow     = Color.new 0xFF, 0xFF, 0x00, 0xFF
-    Green      = Color.new 0x00, 0xFF, 0x00, 0xFF
-    Blue       = Color.new 0x00, 0x00, 0xFF, 0xFF
-    Purple     = Color.new 0XFF, 0x00, 0xFF, 0xFF
+    Background = Color.from 0x00000000, "Transparent"
+    Black      = Color.from 0x000000FF, "Black"
+    Blue       = Color.from 0x0000FFFF, "Blue"
+    Brown      = Color.from 0x996633FF, "Brown"
+    Bubblegum  = Color.from 0xFF66FFFF, "Bubblegum"
+    Cyan       = Color.from 0x00FFFFFF, "Cyan"
+    Gray       = Color.from 0x7F7F7FFF, "Gray"
+    Green      = Color.from 0x00FF00FF, "Green"
+    Magenta    = Color.from 0xFF00FFFF, "Magenta"
+    Orange     = Color.from 0xFF7F00FF, "Orange"
+    Purple     = Color.from 0x7F007FFF, "Purple"
+    Red        = Color.from 0xFF0000FF, "Red"
+    White      = Color.from 0xFFFFFFFF, "White"
+    Yellow     = Color.from 0xFFFF00FF, "Yellow"
+
+    def ==(other) # :nodoc:
+      self.class === other and other.values == values
+    end
 
     ##
     # Red component
@@ -147,13 +341,37 @@ class PNG
     # Returns a new color with an alpha value adjusted by +i+.
 
     def intensity(i)
-      return Color.new(r,b,g,(a*i) >> 8)
+      return Color.new(r,g,b,(a*i) >> 8)
     end
 
     def inspect # :nodoc:
-      "#<%s %02x %02x %02x %02x>" % [self.class, *@values]
+      if @name then
+        "#<%s %s>" % [self.class, @name]
+      else
+        "#<%s %02x %02x %02x %02x>" % [self.class, r, g, b, a]
+      end
     end
 
+    ##
+    # An ASCII representation of this color, almost suitable for making ASCII
+    # art!
+
+    def to_ascii
+      return '  ' if a == 0x00
+      brightness = (((r + g + b) / 3) * a) / 0xFF
+      return '00' if brightness >= 0xc0
+      return '++' if brightness >= 0x7F
+      return ',,' if brightness >= 0x40
+      return '..'
+    end
+
+    def to_s
+      if @name then
+        @name
+      else
+        super
+      end
+    end
   end
 
   ##
@@ -176,39 +394,32 @@ class PNG
 
     attr_reader :data
 
-    def initialize(height, width, background = Color::White)
-      @height = height
+    def initialize(width, height, background = Color::Background)
       @width = width
-      @data = Array.new(@width) { |x| Array.new(@height) { background } }
+      @height = height
+      @data = Array.new(@height) { |x| Array.new(@width, background) }
     end
 
     ##
     # Retrieves the color of the pixel at (+x+, +y+).
 
     def [](x, y)
-      raise "bad x value #{x} >= #{@height}" if x >= @height
-      raise "bad y value #{y} >= #{@width}" if y >= @width
-      @data[y][x]
+      raise "bad x value #{x} >= #{@width}" if x >= @width
+      raise "bad y value #{y} >= #{@height}" if y >= @height
+      @data[@height-y-1][x]
     end
 
     ##
     # Sets the color of the pixel at (+x+, +y+) to +color+.
 
     def []=(x, y, color)
-      raise "bad x value #{x} >= #{@height}" if x >= @height
-      raise "bad y value #{y} >= #{@width}"  if y >= @width
-      @data[y][x] = color
+      raise "bad x value #{x} >= #{@width}" if x >= @width
+      raise "bad y value #{y} >= #{@height}"  if y >= @height
+      @data[@height-y-1][x] = color
     end
 
-    ##
-    # Iterates over each pixel in the canvas.
-
-    def each
-      @data.each_with_index do |row, y|
-        row.each_with_index do |pixel, x|
-          yield x, y, color
-        end
-      end
+    def inspect # :nodoc:
+      '#<%s %dx%d>' % [self.class, @width, @height]
     end
 
     ##
@@ -224,9 +435,10 @@ class PNG
     # http://en.wikipedia.org/wiki/Xiaolin_Wu's_line_algorithm
 
     def line(x0, y0, x1, y1, color)
+      y0, y1, x0, x1 = y1, y0, x1, x0 if y0 > y1
       dx = x1 - x0
       sx = dx < 0 ? -1 : 1
-      dx *= sx # TODO: abs?
+      dx *= sx
       dy = y1 - y0
 
       # 'easy' cases
@@ -245,7 +457,7 @@ class PNG
       end
 
       if dx == dy then
-        Range.new(*[x0,x1].sort).each do |x|
+        x0.step(x1, sx) do |x|
           point(x, y0, color)
           y0 += 1
         end
@@ -259,7 +471,7 @@ class PNG
         e = (dx << 16) / dy
         (y0...y1-1).each do |i|
           e_acc_temp, e_acc = e_acc, (e_acc + e) & 0xFFFF
-          x0 = x0 + sx if (e_acc <= e_acc_temp) 
+          x0 = x0 + sx if (e_acc <= e_acc_temp)
           w = 0xFF-(e_acc >> 8)
           point(x0, y0, color.intensity(w))
           y0 = y0 + 1
@@ -271,7 +483,7 @@ class PNG
 
       # horizontal displacement
       e = (dy << 16) / dx
-      (x0...(x1-sx)).each do |i|
+      (dx - 1).downto(0) do |i|
         e_acc_temp, e_acc = e_acc, (e_acc + e) & 0xFFFF
         y0 += 1 if (e_acc <= e_acc_temp)
         w = 0xFF-(e_acc >> 8)
@@ -282,7 +494,23 @@ class PNG
       point(x1, y1, color)
     end
 
-  end
+    ##
+    # Returns an ASCII representation of this image
 
-end
+    def to_s
+      image = []
+      scale = (@width / 39) + 1
+
+      @data.each_with_index do |row, x|
+        next if x % scale != 0
+        row.each_with_index do |color, y|
+          next if y % scale != 0
+          image << color.to_ascii
+        end
+        image << "\n"
+      end
 
+      return image.join
+    end
+  end
+end

data/lib/png/pie.rb

@@ -0,0 +1,47 @@
+#!/usr/local/bin/ruby -w
+
+require 'png'
+
+class PNG
+  FULL = 360.0
+  HALF = FULL / 2
+
+  def self.angle(x, y)
+    return 0 if x == 0 and y == 0
+    rad_to_deg = 180.0 / Math::PI
+    (Math.atan2(-y, x) * rad_to_deg + 90) % 360
+  end
+
+  ##
+  # Makes a pie chart you can pass to PNG.new:
+  #
+  #   png = PNG.new pie_chart(250, 0.30)
+  #   png.save "pie.png"
+  #   system 'open pie.png'
+
+  def self.pie_chart(diameter, pct_green,
+                good_color=PNG::Color::Green, bad_color=PNG::Color::Red)
+    diameter += 1 if diameter % 2 == 0
+    radius = (diameter / 2.0).to_i
+    pct_in_deg = FULL * pct_green
+    rad_to_deg = HALF / Math::PI
+
+    canvas = PNG::Canvas.new(diameter, diameter)
+
+    (-radius..radius).each do |x|
+      (-radius..radius).each do |y|
+        magnitude = Math.sqrt(x*x + y*y)
+        if magnitude <= radius then
+          angle = PNG.angle(x, y)
+          color = ((angle <= pct_in_deg) ? good_color : bad_color)
+
+          rx, ry = x+radius, y+radius
+
+          canvas[ rx, ry ] = color
+        end
+      end
+    end
+
+    canvas
+  end
+end

data/test/test_png.rb

@@ -0,0 +1,423 @@
+require 'test/unit'
+require 'rubygems'
+require 'png'
+require 'png/pie'
+
+class TestPng < Test::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
+  end
+
+  def test_class_chunk_empty
+    chunk = PNG.chunk 'IHDR'
+    expected = "#{0.chr * 4}IHDR#{["IHDR".png_crc].pack 'N'}"
+    assert_equal expected, chunk
+  end
+
+  def test_to_blob
+    assert_equal @blob, @png.to_blob
+  end
+
+  def test_save
+    path = "blah.png"
+    @png.save(path)
+    assert_equal @blob, File.read(path)
+  ensure
+    assert_equal 1, File.unlink(path)
+  end
+
+class TestCanvas < Test::Unit::TestCase
+
+  def setup
+    @canvas = PNG::Canvas.new 5, 10, PNG::Color::White
+  end
+
+  def test_index
+    assert_equal PNG::Color::White, @canvas[1, 2]
+    assert_same @canvas[1, 2], @canvas.data[1][2]
+  end
+
+  def test_index_tall
+    @canvas = PNG::Canvas.new 2, 4, PNG::Color::White
+    @canvas[ 0, 0] = PNG::Color::Black
+    @canvas[ 0, 3] = PNG::Color::Background
+    @canvas[ 1, 0] = PNG::Color::Yellow
+    @canvas[ 1, 3] = PNG::Color::Blue
+
+    expected = "  ,,\n0000\n0000\n..++\n"
+
+    assert_equal expected, @canvas.to_s
+  end
+
+  def test_index_wide
+    @canvas = PNG::Canvas.new 4, 2, PNG::Color::White
+    @canvas[ 0, 0] = PNG::Color::Black
+    @canvas[ 3, 0] = PNG::Color::Background
+    @canvas[ 0, 1] = PNG::Color::Yellow
+    @canvas[ 3, 1] = PNG::Color::Blue
+
+    expected = "++0000,,\n..0000  \n"
+
+    assert_equal expected, @canvas.to_s
+  end
+
+  def test_index_bad_x
+    begin
+      @canvas[6, 1]
+    rescue => e
+      assert_equal "bad x value 6 >= 5", e.message
+    else
+      flunk "didn't raise"
+    end
+  end
+
+  def test_index_bad_y
+    begin
+      @canvas[1, 11]
+    rescue => e
+      assert_equal "bad y value 11 >= 10", e.message
+    else
+      flunk "didn't raise"
+    end
+  end
+
+  def test_index_equals
+    @canvas[1, 2] = PNG::Color::Red
+    assert_equal PNG::Color::Red, @canvas[1, 2]
+    assert_same @canvas[1, 2], @canvas.data[7][1]
+
+    expected = "
+0000000000
+0000000000
+0000000000
+0000000000
+0000000000
+0000000000
+0000000000
+00,,000000
+0000000000
+0000000000".strip + "\n"
+    actual = @canvas.to_s
+    assert_equal expected, actual
+  end
+
+  def test_index_equals_bad_x
+    begin
+      @canvas[6, 1] = PNG::Color::Red
+    rescue => e
+      assert_equal "bad x value 6 >= 5", e.message
+    else
+      flunk "didn't raise"
+    end
+  end
+
+  def test_index_equals_bad_y
+    begin
+      @canvas[1, 11] = PNG::Color::Red
+    rescue => e
+      assert_equal "bad y value 11 >= 10", e.message
+    else
+      flunk "didn't raise"
+    end
+  end
+
+#   def test_point
+#     raise NotImplementedError, 'Need to write test_point'
+#   end
+
+  def test_inspect
+    assert_equal "#<PNG::Canvas 5x10>", @canvas.inspect
+  end
+
+  def test_point
+    assert_equal PNG::Color.new(0xfe, 0x00, 0xfe, 0xfe),
+                 @canvas.point(0, 0, PNG::Color::Magenta)
+    # flunk "this doesn't test ANYTHING"
+  end
+
+  def test_line
+    @canvas.line 0, 9, 4, 0, PNG::Color::Black
+
+    expected = <<-EOF
+..00000000
+,,00000000
+00,,000000
+00..000000
+00++++0000
+0000..0000
+0000++++00
+000000..00
+000000,,00
+00000000..
+    EOF
+
+    assert_equal expected, @canvas.to_s
+  end
+
+  def test_positive_slope_line
+    @canvas.line 0, 0, 4, 9, PNG::Color::Black
+
+    expected = <<-EOF
+00000000..
+00000000,,
+000000,,00
+000000..00
+0000++++00
+0000..0000
+00++++0000
+00..000000
+00,,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)
+    assert_equal expected, @canvas.to_s
+  end
+
+  def test_to_s_wide
+    @canvas = PNG::Canvas.new 250, 10, PNG::Color::White
+    expected = util_ascii_art(36, 2) # scaled
+    assert_equal expected, @canvas.to_s
+  end
+
+  def test_to_s_tall
+    @canvas = PNG::Canvas.new 10, 250, PNG::Color::White
+    expected = util_ascii_art(10, 250)
+    assert_equal expected, @canvas.to_s
+  end
+
+  def test_to_s_huge
+    @canvas = PNG::Canvas.new 250, 250, PNG::Color::White
+    expected = util_ascii_art(36, 36) # scaled
+    assert_equal expected, @canvas.to_s
+  end
+
+#   def test_class_read_chunk
+#     type, data = PNG.read_chunk @IHDR_chunk
+
+#     assert_equal 'IHDR', type
+#     assert_equal @IHDR_data, data
+#   end
+
+#   def test_class_read_IDAT
+#     canvas = PNG::Canvas.new 10, 10, PNG::Color::White
+
+#     data = "x\332c\370O$`\030UH_\205\000#\373\216\200"
+
+#     PNG.read_IDAT data, canvas
+
+#     assert_equal @blob, PNG.new(canvas).to_blob
+#   end
+
+#   def test_class_read_IHDR
+#     canvas = PNG.read_IHDR @IHDR_data
+#     assert_equal 10, canvas.width
+#     assert_equal 10, canvas.height
+#   end
+end
+
+class TestPng::TestColor < Test::Unit::TestCase
+  def setup
+    @color = PNG::Color.new 0x01, 0x02, 0x03, 0x04
+  end
+
+  def test_class_from_str
+    @color = PNG::Color.from "0x01020304"
+    test_r
+    test_g
+    test_b
+    test_a
+  end
+
+  def test_class_from_int
+    @color = PNG::Color.from 0x01020304
+    test_r
+    test_g
+    test_b
+    test_a
+  end
+
+  def test_r
+    assert_equal 0x01, @color.r
+  end
+
+  def test_g
+    assert_equal 0x02, @color.g
+  end
+
+  def test_b
+    assert_equal 0x03, @color.b
+  end
+
+  def test_a
+    assert_equal 0x04, @color.a
+  end
+
+  def test_blend
+    c1 = @color
+    c2 = PNG::Color.new 0xFF, 0xFE, 0xFD, 0xFC
+
+    assert_equal PNG::Color.new(0xfb, 0xfa, 0xf9, 0xf8), c1.blend(c2)
+  end
+
+  def test_intensity
+    assert_equal PNG::Color.new(0x01, 0x02, 0x03, 0x3c), @color.intensity(0xf00)
+  end
+
+  def test_inspect
+    assert_equal "#<PNG::Color 01 02 03 04>", @color.inspect
+  end
+
+  def test_inspect_name
+    assert_equal "#<PNG::Color Red>", PNG::Color::Red.inspect
+  end
+
+  def test_to_ascii
+    assert_equal '00', PNG::Color::White.to_ascii, "white"
+    assert_equal '++', PNG::Color::Yellow.to_ascii, "yellow"
+    assert_equal ',,', PNG::Color::Red.to_ascii, "red"
+    assert_equal '..', PNG::Color::Black.to_ascii, "black"
+    assert_equal '  ', PNG::Color::Background.to_ascii, "background"
+  end
+
+  def test_to_ascii_alpha
+    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,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
+    assert_equal '..', PNG::Color.new(255,255,255,  1).to_ascii
+    assert_equal '  ', PNG::Color.new(255,255,255,  0).to_ascii
+  end
+
+  def test_to_s_name
+    assert_equal 'Red', PNG::Color::Red.to_s
+  end
+
+  def test_to_s
+    obj = PNG::Color.new(255,255,255,  0)
+    assert_equal '#<PNG::Color:0xXXXXXX>', obj.to_s.sub(/0x[0-9a-f]+/, '0xXXXXXX')
+  end
+
+#   def test_values
+#     raise NotImplementedError, 'Need to write test_values'
+#   end
+end
+
+end
+
+class TestPng::TestPie < Test::Unit::TestCase
+  def setup
+
+  end
+
+  def test_pie_chart_odd
+    expected =
+      ["          ..          ",
+       "    ,,,,,,........    ",
+       "  ,,,,,,,,..........  ",
+       "  ,,,,,,,,..........  ",
+       "  ,,,,,,,,..........  ",
+       ",,,,,,,,,,............",
+       "  ,,,,,,,,,,,,,,,,,,  ",
+       "  ,,,,,,,,,,,,,,,,,,  ",
+       "  ,,,,,,,,,,,,,,,,,,  ",
+       "    ,,,,,,,,,,,,,,    ",
+       "          ,,          ",
+      nil].join("\n")
+
+    actual = PNG::pie_chart(11, 0.25, PNG::Color::Black, PNG::Color::Green)
+    assert_equal expected, actual.to_s
+  end
+
+  def test_pie_chart_even
+    expected =
+      ["          ..          ",
+       "    ,,,,,,........    ",
+       "  ,,,,,,,,..........  ",
+       "  ,,,,,,,,..........  ",
+       "  ,,,,,,,,..........  ",
+       ",,,,,,,,,,............",
+       "  ,,,,,,,,,,,,,,,,,,  ",
+       "  ,,,,,,,,,,,,,,,,,,  ",
+       "  ,,,,,,,,,,,,,,,,,,  ",
+       "    ,,,,,,,,,,,,,,    ",
+       "          ,,          ",
+      nil].join("\n")
+
+    actual = PNG::pie_chart(10, 0.25, PNG::Color::Black, PNG::Color::Green)
+    assert_equal expected, actual.to_s
+  end
+
+  def util_angle(expect, x, y)
+    actual = PNG.angle(x, y)
+    case expect
+    when Integer then
+      assert_equal(expect, actual,
+                   "[#{x}, #{y}] should be == #{expect}, was #{actual}")
+    else
+      assert_in_delta(expect, actual, 0.5)
+    end
+  end
+
+  def test_math_is_hard_lets_go_shopping
+    util_angle   0,  0,  0
+    (25..500).step(25) do |n|
+      util_angle   0,  0,  n
+      util_angle  90,  n,  0
+      util_angle 180,  0, -n
+      util_angle 270, -n,  0
+    end
+
+    util_angle 359.5, -1, 250
+    util_angle   0.0,  0, 250
+    util_angle   0.5,  1, 250
+
+    util_angle 89.5, 250,  1
+    util_angle 90.0, 250,  0
+    util_angle 90.5, 250, -1
+  end
+end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.99
+rubygems_version: 0.9.0.9
 specification_version: 1
 name: png
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
-date: 2006-08-31 00:00:00 -07:00
-summary: A pure ruby PNG library
+  version: 1.1.0
+date: 2007-03-26 00:00:00 -07:00
+summary: An almost-pure-ruby PNG library
 require_paths: 
 - lib
-email: ryand-ruby@zenspider.com
-homepage: 
-rubyforge_project: 
-description: png allows you to write a PNG file without any C libraries.
+email: support@zenspider.com
+homepage: http://www.zenspider.com/ZSS/Products/png/
+rubyforge_project: seattlerb
+description: "PNG is an almost-pure-ruby PNG library. It lets you write a PNG without any C libraries.  == FEATURES  * Very simple interface. * Outputs simple PNG files with ease. * Basic PNG reader as well (someday it might do compositing and the like!). * Almost pure ruby, does require a compiler.  == SYNOPSYS  require 'png'  canvas = PNG::Canvas.new 200, 200  # Set a point to a color canvas[100, 100] = PNG::Color::Black  # draw an anti-aliased line canvas.line 50, 50, 100, 50, PNG::Color::Blue  png = PNG.new canvas png.save 'blah.png'"
 autorequire: 
 default_executable: 
 bindir: bin
@@ -28,14 +28,20 @@ cert_chain:
 post_install_message: 
 authors: 
 - Ryan Davis
+- Eric Hodel
 files: 
+- History.txt
 - Manifest.txt
-- README
+- README.txt
 - Rakefile
 - example/lines.rb
+- example/profile.rb
+- example/profile_lines.rb
 - lib/png.rb
-test_files: []
-
+- lib/png/pie.rb
+- test/test_png.rb
+test_files: 
+- test/test_png.rb
 rdoc_options: []
 
 extra_rdoc_files: []
@@ -46,5 +52,22 @@ extensions: []
 
 requirements: []
 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: RubyInline
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.5.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: 

data/README

@@ -1,28 +0,0 @@
-= png
-
-== About
-
-png is a pure-ruby PNG library.  It lets you write a PNG without any C
-libraries.  Of course it is "slow".
-
-== Installing png
-
-Just install the gem:
-
-  $ sudo gem install png
-
-== Using png
-
-  require 'png'
-  
-  canvas = PNG::Canvas.new 200, 200
-  
-  # Set a point to a color
-  canvas[100, 100] = PNG::Color::Black
-  
-  # draw an anti-aliased line
-  canvas.line 50, 50, 100, 50, PNG::Color::Blue
-  
-  png = PNG.new canvas
-  png.save 'blah.png'
-