png 1.0.0

data/Manifest.txt

@@ -0,0 +1,5 @@
+Manifest.txt
+README
+Rakefile
+example/lines.rb
+lib/png.rb

data/README

@@ -0,0 +1,28 @@
+= 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'
+

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+$VERBOSE = nil
+
+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.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
+
+desc 'Build Gem'
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+end
+
+desc 'Clean up'
+task :clean => [ :clobber_rdoc, :clobber_package ]
+
+desc 'Clean up'
+task :clobber => [ :clean ]
+
+# vim: syntax=Ruby

data/example/lines.rb

@@ -0,0 +1,27 @@
+#!/usr/local/bin/ruby -w
+
+require 'png'
+
+canvas = PNG::Canvas.new 1024, 1024, PNG::Color::Black
+
+#canvas.each do |x, y|
+#  case x
+#  when y then
+#    canvas.point(x, y, Color::Black)
+#  when 50 then
+#    canvas.point(x, y, Color::Background)
+#  end
+#  canvas.point(x, y, Color::Green) if y = 200
+#end
+
+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   0, 200, 200,   0, PNG::Color::Black
+
+png = PNG.new canvas
+png.save 'blah.png'
+`open blah.png`
+

data/lib/png.rb

@@ -0,0 +1,288 @@
+require 'zlib'
+
+class String # :nodoc:
+
+  ##
+  # 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
+    end
+
+    c = 0xffffffff
+    each_byte do |b|
+      c = @@crc[(c^b) & 0xff] ^ (c >> 8)
+    end
+    return c ^ 0xffffffff
+  end
+
+end
+
+##
+# A 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'
+
+class PNG
+
+  ##
+  # 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, "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
+  end
+
+  ##
+  # RGBA colors
+
+  class Color
+
+    attr_reader :values
+
+    ##
+    # Creates a new color with values +red+, +green+, +blue+, and +alpha+.
+
+    def initialize(red, green, blue, alpha)
+      @values = [red, green, blue, alpha]
+    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
+
+    ##
+    # 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 * (0xFF - color.a) + color.r * color.a) >> 8,
+                       (g * (0xFF - color.a) + color.g * color.a) >> 8,
+                       (b * (0xFF - color.a) + color.b * color.a) >> 8,
+                       (a * (0xFF - color.a) + color.a * color.a) >> 8)
+    end
+
+    ##
+    # Returns a new color with an alpha value adjusted by +i+.
+
+    def intensity(i)
+      return Color.new(r,b,g,(a*i) >> 8)
+    end
+
+    def inspect # :nodoc:
+      "#<%s %02x %02x %02x %02x>" % [self.class, *@values]
+    end
+
+  end
+
+  ##
+  # PNG canvas
+
+  class Canvas
+
+    ##
+    # Height of the canvas
+
+    attr_reader :height
+
+    ##
+    # Width of the canvas
+
+    attr_reader :width
+
+    ##
+    # Raw data
+
+    attr_reader :data
+
+    def initialize(height, width, background = Color::White)
+      @height = height
+      @width = width
+      @data = Array.new(@width) { |x| Array.new(@height) { 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]
+    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
+    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
+    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)
+      dx = x1 - x0
+      sx = dx < 0 ? -1 : 1
+      dx *= sx # TODO: abs?
+      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
+        Range.new(*[x0,x1].sort).each 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
+      (x0...(x1-sx)).each 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
+
+  end
+
+end
+

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.99
+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
+require_paths: 
+- lib
+email: ryand-ruby@zenspider.com
+homepage: 
+rubyforge_project: 
+description: png allows you to write a PNG file without any C libraries.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Ryan Davis
+files: 
+- Manifest.txt
+- README
+- Rakefile
+- example/lines.rb
+- lib/png.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+