aslakhellesoy-png 1.2.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

@@ -0,0 +1,13 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+example/lines.rb
+example/profile.rb
+example/profile_lines.rb
+lib/png.rb
+lib/png/default_font.png
+lib/png/font.rb
+lib/png/pie.rb
+lib/png/reader.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

@@ -0,0 +1,19 @@
+$: << "../../RubyInline/dev/lib"
+
+require 'hoe'
+require './lib/png.rb'
+
+Hoe.add_include_dirs("../../RubyInline/dev/lib",
+                     "lib")
+
+Hoe.new 'png', PNG::VERSION do |png|
+  png.rubyforge_name = 'seattlerb'
+
+  png.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
+  png.developer('Eric Hodel', 'drbrain@segment7.net')
+
+  png.clean_globs << File.expand_path("~/.ruby_inline")
+  png.extra_deps << ['RubyInline', '>= 3.5.0']
+end
+
+# vim: syntax=Ruby

data/example/lines.rb

@@ -0,0 +1,20 @@
+#!/usr/local/bin/ruby -w
+
+require 'png'
+require 'png/font'
+
+canvas = PNG::Canvas.new 201, 201, PNG::Color::White
+
+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
+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
+
+canvas.annotate 'Hello World', 10, 10
+
+png = PNG.new canvas
+png.save 'blah.png'
+`open 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

@@ -0,0 +1,584 @@
+require 'rubygems'
+require 'zlib'
+require 'inline'
+
+class String # :nodoc: # ZenTest SKIP
+  inline do |builder|
+    raise CompilationError if defined?(JRUBY_VERSION)
+    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
+
+    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
+rescue CompilationError
+  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
+  end
+
+  ##
+  # Calculates a CRC using the algorithm in the PNG specification.
+
+  def png_crc()
+    c = 0xffffffff
+    each_byte do |b|
+      c = @@crc[(c^b) & 0xff] ^ (c >> 8)
+    end
+    return c ^ 0xffffffff
+  end
+end
+
+##
+# An almost-pure-ruby Portable Network Graphics (PNG) writer.
+#
+# http://www.libpng.org/pub/png/spec/1.2/
+#
+# PNG supports:
+# + 8 bit truecolor PNGs
+#
+# PNG does not support:
+# + any other color depth
+# + extra data chunks
+# + filters
+#
+# = Example
+#
+#   require 'png'
+#
+#   canvas = PNG::Canvas.new 200, 200
+#   canvas[100, 100] = PNG::Color::Black
+#   canvas.line 50, 50, 100, 50, PNG::Color::Blue
+#   png = PNG.new canvas
+#   png.save 'blah.png'
+#
+# = TODO:
+#
+# + Get everything orinted entirely on [x,y,h,w] with x,y origin being
+#   bottom left.
+
+class PNG
+  VERSION = '1.2.0'
+  SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10].pack("C*")
+
+  # Color Types:
+  GRAY    = 0 # DEPTH = 1,2,4,8,16
+  RGB     = 2 # DEPTH = 8,16
+  INDEXED = 3 # DEPTH = 1,2,4,8
+  GRAYA   = 4 # DEPTH = 8,16
+  RGBA    = 6 # DEPTH = 8,16
+
+  # Filter Types:
+  NONE    = 0
+  SUB     = 1
+  UP      = 2
+  AVG     = 3
+  PAETH   = 4
+
+  begin
+    inline do |builder|
+      raise CompilationError if defined?(JRUBY_VERSION)
+      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
+
+      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
+  rescue CompilationError
+    def png_join
+      @data.map { |row| "\0" + row.map { |p| p.values }.join }.join
+    end
+  end
+
+  ##
+  # Creates a PNG chunk of type +type+ that contains +data+.
+
+  def self.chunk(type, data="")
+    [data.size, type, data, (type + data).png_crc].pack("Na*a*N")
+  end
+
+  ##
+  # Creates a new PNG object using +canvas+
+
+  def initialize(canvas)
+    @height = canvas.height
+    @width = canvas.width
+    @bits = 8
+    @data = canvas.data
+  end
+
+  ##
+  # Writes the PNG to +path+.
+
+  def save(path)
+    File.open path, 'wb' do |f|
+      f.write to_blob
+    end
+  end
+
+  ##
+  # Raw PNG data
+
+  def to_blob
+    blob = []
+
+    header = [@width, @height, @bits, RGBA, NONE, NONE, NONE]
+
+    blob << SIGNATURE
+    blob << PNG.chunk('IHDR', header.pack("N2C5"))
+    blob << PNG.chunk('IDAT', Zlib::Deflate.deflate(self.png_join))
+    blob << PNG.chunk('IEND', '')
+    blob.join
+  end
+
+  ##
+  # A 32 bit RGBA color. Can be created from RGB or RGBA via #new,
+  # numeric value or hex string via #from, or HSV via #from_hsv.
+
+  class Color
+
+    MAX=255
+
+    attr_reader :values
+
+    ##
+    # Create a new color from a string or integer value. Can take an
+    # optional name as well.
+
+    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 = MAX, name = nil
+      @values = "%c%c%c%c" % [red, green, blue, alpha]
+      @name = name
+    end
+
+    ##
+    # Transparent white
+
+    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
+
+    alias :eql? :==
+
+    ##
+    # "Bitwise or" as applied to colors. Background color is
+    # considered false.
+
+    def | o
+      self == Background ? o : self
+    end
+
+    def hash # :nodoc:
+      self.values.hash
+    end
+
+    ##
+    # Return an array of RGB
+
+    def rgb # TODO: rgba?
+      return @values[0], @values[1], @values[2]
+    end
+
+    ##
+    # Red component
+
+    def r; @values[0]; end
+
+    ##
+    # Green component
+
+    def g; @values[1]; end
+
+    ##
+    # Blue component
+
+    def b; @values[2]; end
+
+    ##
+    # Alpha transparency component
+
+    def a; @values[3]; end
+
+    ##
+    # Blends +color+ into this color returning a new blended color.
+
+    def blend color
+      return Color.new(((r + color.r) / 2), ((g + color.g) / 2),
+                       ((b + color.b) / 2), ((a + color.a) / 2))
+    end
+
+    ##
+    # Returns a new color with an alpha value adjusted by +i+.
+
+    def intensity i
+      return Color.new(r,g,b,(a*i) >> 8)
+    end
+
+    def inspect # :nodoc:
+      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
+
+      %w(.. ,, ++ 00)[brightness / 64]
+    end
+
+    def to_s # :nodoc:
+      if @name then
+        @name
+      else
+        super
+      end
+    end
+
+    ##
+    # Creates a new RGB color from HSV equivalent values.
+
+    def self.from_hsv h, s, v
+      r = g = b = v # gray
+      unless s == 0.0 then
+        h += 255 if h < 0
+        h  = h / 255.0 * 6.0
+        s  = s / 255.0
+        v  = v / 255.0
+        i  = h.floor
+        f  = h - i
+        p = v * (1 - (s))
+        q = v * (1 - (s * (f)))
+        w = v * (1 - (s * (1-f)))
+        r, g, b = case i
+                  when 0,6 then
+                    [ v, w, p ]
+                  when 1 then
+                    [ q, v, p ]
+                  when 2 then
+                    [ p, v, w ]
+                  when 3 then
+                    [ p, q, v ]
+                  when 4 then
+                    [ w, p, v ]
+                  when 5 then
+                    [ v, p, q ]
+                  else
+                    raise [h, s, v, i, f, p, q, w].inspect
+                  end
+      end
+      self.new((r * 255).round, (g * 255).round, (b * 255).round)
+    end
+
+    ##
+    # Returns HSV equivalent of the current color.
+
+    def to_hsv # errors = 54230 out of 255^3 are off by about 1 on r, g, or b
+      rgb = self.rgb
+      r, g, b = rgb
+      h, s, v = 0, 0, rgb.max
+
+      return h, s, v if v == 0
+
+      range = v - rgb.min
+      s = 255 * range / v
+
+      return h, s, v if s == 0
+
+      h = case v
+          when r then
+            0x00 + 43 * (g - b) / range # 43 = 1/4 of 360 scaled to 255
+          when g then
+            0x55 + 43 * (b - r) / range
+          else
+            0xAA + 43 * (r - g) / range
+          end
+
+      return h.round, s.round, v.round
+    end
+  end # Color
+
+  ##
+  # A canvas used for drawing images. Origin is 0, 0 in the bottom
+  # left corner.
+
+  class Canvas
+
+    ##
+    # Height of the canvas
+
+    attr_reader :height
+
+    ##
+    # Width of the canvas
+
+    attr_reader :width
+
+    ##
+    # Raw data
+
+    attr_reader :data
+
+    def initialize width, height, background = Color::Background
+      @width = width
+      @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} >= #{@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} >= #{@width}" if x >= @width
+      raise "bad y value #{y} >= #{@height}"  if y >= @height
+      raise "bad color #{color.inspect}" unless color.kind_of? PNG::Color
+      @data[@height-y-1][x] = color
+    end
+
+    ##
+    # Composites another canvas onto self at the given (bottom left) coordinates.
+
+    def composite canvas, x, y, style = :overwrite
+      canvas.each do |x1, y1, color|
+        case style
+        when :overwrite then
+          self[x+x1, y+y1] = color
+        when :add, :underlay then
+          self[x+x1, y+y1] = self[x+x1, y+y1] | color
+        when :overlay then
+          self[x+x1, y+y1] = color | self[x+x1, y+y1]
+        when :blend then
+          self.point x+x1, y+y1, color
+        else
+          raise "unknown style for composite: #{style.inspect}"
+        end
+      end
+    end
+
+    ##
+    # Iterates over the canvas yielding x, y, and color.
+
+    def each
+      data.reverse.each_with_index do |row, y|
+        row.each_with_index do |color, x|
+          yield x, y, color
+        end
+      end
+    end
+
+    ##
+    # Create a new canvas copying a region of the current canvas
+
+    def extract x0, y0, x1, y1
+      canvas = Canvas.new(x1-x0+1, y1-y0+1)
+
+      (x0..x1).each_with_index do |x2, x3|
+        (y0..y1).each_with_index do |y2, y3|
+          canvas[x3, y3] = self[x2, y2]
+        end
+      end
+
+      canvas
+    end
+
+    def inspect # :nodoc:
+      '#<%s %dx%d>' % [self.class, @width, @height]
+    end
+
+    ##
+    # Blends +color+ onto the color at point (+x+, +y+).
+
+    def point(x, y, color)
+      self[x,y] = self[x,y].blend(color)
+    end
+
+    ##
+    # Draws a line using Xiaolin Wu's antialiasing technique.
+    #
+    # 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
+      dy = y1 - y0
+
+      # 'easy' cases
+      if dy == 0 then
+        Range.new(*[x0,x1].sort).each do |x|
+          point(x, y0, color)
+        end
+        return
+      end
+
+      if dx == 0 then
+        (y0..y1).each do |y|
+          point(x0, y, color)
+        end
+        return
+      end
+
+      if dx == dy then
+        x0.step(x1, sx) do |x|
+          point(x, y0, color)
+          y0 += 1
+        end
+        return
+      end
+
+      # main loop
+      point(x0, y0, color)
+      e_acc = 0
+      if dy > dx then # vertical displacement
+        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)
+          w = 0xFF-(e_acc >> 8)
+          point(x0, y0, color.intensity(w))
+          y0 = y0 + 1
+          point(x0 + sx, y0, color.intensity(0xFF-w))
+        end
+        point(x1, y1, color)
+        return
+      end
+
+      # horizontal displacement
+      e = (dy << 16) / dx
+      (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)
+        point(x0, y0, color.intensity(w))
+        x0 += sx
+        point(x0, y0 + 1, color.intensity(0xFF-w))
+      end
+      point(x1, y1, color)
+    end
+
+    ##
+    # Returns an ASCII representation of this image
+
+    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 # Canvas
+end