chunky_png 0.5.3 → 0.5.4

data/README.rdoc

@@ -16,7 +16,7 @@ Issue tracker:: http://github.com/wvanbergen/chunky_png/issues
   color modes and all transparency, interlacing and filtering options.
 * Encodes images supports all color modes (true color, grayscale and indexed)
   and transparency for all these color modes. The best color mode will be
-  chosen automatically, based on the image's colors.
+  chosen automatically, based on the amount of used colors.
 * R/W access to the image's pixels.
 * R/W access to all image metadata that is stored in chunks.
 * Memory efficient (uses a Fixnum, i.e. 4 bytes of memory, per pixel)
@@ -26,12 +26,12 @@ Issue tracker:: http://github.com/wvanbergen/chunky_png/issues
 
 == Classes
 
-The main classes used within ChunkyPNG are:
+The main classes and modules used within ChunkyPNG are:
 
 <tt>ChunkyPNG::Image</tt> :: create PNG images from scratch or based on another PNG image.
 <tt>ChunkyPNG::Datastream</tt> :: low-level read and write access to PNG images from or to a file or stream.
 <tt>ChunkyPNG::Canvas</tt> :: represents an image canvas as a matrix of pixels.
-<tt>ChunkyPNG::Color</tt> :: represents a, RGBA color
+<tt>ChunkyPNG::Color</tt> :: to handle Fixnums as color values.
 
 == Usage
 
@@ -53,19 +53,17 @@ The main classes used within ChunkyPNG are:
   image = ChunkyPNG::Image.from_file('with_metadata.png')
   puts image.metadata['Title']
   image.metadata['Author'] = 'Willem van Bergen'
-  image.save('with_metadata.png') # Overwrite
+  image.save('with_metadata.png') # Overwrite file
   
   # Low level access to PNG chunks
   png_stream = ChunkyPNG::Datastream.from_file('filename.png')
   png_stream.each_chunk { |chunk| p chunk.type }
 
-(Note: this is subject to change while work is in progress)
-
 == About
 
 The library is written by Willem van Bergen for Floorplanner.com, and released
 under the MIT license (see LICENSE). Please contact me for questions or
-remarks. Patches are greatly appreciated! :-)
+remarks. Patches are greatly appreciated!
 
 P.S.: The name of this library is intentionally similar to Chunky Bacon and 
-Chunky GIF. Use Google if you want to know _why.
+Chunky GIF. Use Google if you want to know _why. :-)

data/chunky_png.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
 
   # Do not change the version and date fields by hand. This will be done
   # automatically by the gem release script.
-  s.version = "0.5.3"
-  s.date    = "2010-01-17"
+  s.version = "0.5.4"
+  s.date    = "2010-01-18"
 
   s.summary     = "Pure ruby library for read/write, chunk-level access to PNG files"
   s.description = <<-EOT
@@ -32,6 +32,6 @@ Gem::Specification.new do |s|
 
   # Do not change the files and test_files fields by hand. This will be done
   # automatically by the gem release script.
-  s.files      = %w(spec/spec_helper.rb spec/resources/ztxt_chunk.png spec/resources/text_chunk.png spec/resources/replaced.png spec/resources/pixelstream.rgb spec/resources/indexed_4bit.png spec/resources/gray_10x10_grayscale.png spec/resources/damaged_signature.png spec/resources/damaged_chunk.png spec/chunky_png/canvas/png_encoding_spec.rb lib/chunky_png/canvas/stream_exporting.rb spec/resources/gray_10x10.png lib/chunky_png/color.rb lib/chunky_png/canvas/operations.rb .gitignore spec/resources/gray_10x10_truecolor_alpha.png spec/chunky_png/canvas_spec.rb LICENSE spec/resources/gray_10x10_truecolor.png spec/resources/composited.png spec/chunky_png/color_spec.rb spec/chunky_png/canvas/adam7_interlacing_spec.rb lib/chunky_png/chunk.rb lib/chunky_png/canvas/stream_importing.rb lib/chunky_png/canvas/png_encoding.rb lib/chunky_png/canvas/adam7_interlacing.rb spec/resources/operations.png spec/chunky_png/canvas/png_decoding_spec.rb lib/chunky_png/canvas.rb Rakefile spec/resources/transparent_gray_10x10.png spec/resources/pixelstream.rgba spec/resources/cropped.png README.rdoc spec/resources/gray_10x10_indexed.png spec/resources/16x16_non_interlaced.png spec/chunky_png_spec.rb lib/chunky_png/palette.rb lib/chunky_png/datastream.rb chunky_png.gemspec tasks/github-gem.rake spec/resources/pixelstream_reference.png spec/resources/gray_10x10_grayscale_alpha.png spec/resources/16x16_interlaced.png spec/chunky_png/image_spec.rb lib/chunky_png/canvas/drawing.rb spec/resources/adam7.png lib/chunky_png/rmagick.rb lib/chunky_png/image.rb spec/chunky_png/rmagick_spec.rb spec/chunky_png/datastream_spec.rb lib/chunky_png/canvas/png_decoding.rb lib/chunky_png.rb)
-  s.test_files = %w(spec/chunky_png/canvas/png_encoding_spec.rb spec/chunky_png/canvas_spec.rb spec/chunky_png/color_spec.rb spec/chunky_png/canvas/adam7_interlacing_spec.rb spec/chunky_png/canvas/png_decoding_spec.rb spec/chunky_png_spec.rb spec/chunky_png/image_spec.rb spec/chunky_png/rmagick_spec.rb spec/chunky_png/datastream_spec.rb)
+  s.files      = %w(spec/spec_helper.rb spec/resources/ztxt_chunk.png spec/resources/text_chunk.png spec/resources/replaced.png spec/resources/pixelstream.rgb spec/resources/indexed_4bit.png spec/resources/gray_10x10_grayscale.png spec/resources/damaged_signature.png spec/resources/damaged_chunk.png spec/chunky_png/canvas/png_encoding_spec.rb lib/chunky_png/canvas/stream_exporting.rb spec/resources/gray_10x10.png lib/chunky_png/color.rb lib/chunky_png/canvas/operations.rb .gitignore spec/resources/gray_10x10_truecolor_alpha.png spec/chunky_png/canvas_spec.rb LICENSE spec/resources/gray_10x10_truecolor.png spec/resources/composited.png spec/chunky_png/color_spec.rb spec/chunky_png/canvas/adam7_interlacing_spec.rb lib/chunky_png/chunk.rb lib/chunky_png/canvas/stream_importing.rb lib/chunky_png/canvas/png_encoding.rb lib/chunky_png/canvas/adam7_interlacing.rb spec/resources/operations.png spec/chunky_png/canvas/png_decoding_spec.rb lib/chunky_png/canvas.rb Rakefile spec/resources/transparent_gray_10x10.png spec/resources/pixelstream.rgba spec/resources/cropped.png README.rdoc spec/resources/gray_10x10_indexed.png spec/resources/16x16_non_interlaced.png spec/chunky_png_spec.rb spec/chunky_png/canvas/drawing_spec.rb lib/chunky_png/palette.rb lib/chunky_png/datastream.rb chunky_png.gemspec tasks/github-gem.rake spec/resources/pixelstream_reference.png spec/resources/lines.png spec/resources/gray_10x10_grayscale_alpha.png spec/resources/16x16_interlaced.png spec/chunky_png/image_spec.rb lib/chunky_png/canvas/drawing.rb spec/resources/adam7.png lib/chunky_png/rmagick.rb lib/chunky_png/image.rb spec/chunky_png/rmagick_spec.rb spec/chunky_png/datastream_spec.rb lib/chunky_png/canvas/png_decoding.rb lib/chunky_png.rb)
+  s.test_files = %w(spec/chunky_png/canvas/png_encoding_spec.rb spec/chunky_png/canvas_spec.rb spec/chunky_png/color_spec.rb spec/chunky_png/canvas/adam7_interlacing_spec.rb spec/chunky_png/canvas/png_decoding_spec.rb spec/chunky_png_spec.rb spec/chunky_png/canvas/drawing_spec.rb spec/chunky_png/image_spec.rb spec/chunky_png/rmagick_spec.rb spec/chunky_png/datastream_spec.rb)
 end

data/lib/chunky_png.rb

@@ -16,15 +16,17 @@ require 'chunky_png/canvas/drawing'
 require 'chunky_png/canvas'
 require 'chunky_png/image'
 
-# ChunkyPNG
+# ChunkyPNG - the pury ruby library to access PNG files.
 #
 # The ChunkyPNG module defines some constants that are used in the
 # PNG specification.
+#
+# @author Willem van Bergen
 module ChunkyPNG
 
   # The current version of ChunkyPNG. This value will be updated automatically
   # by them gem:release rake task.
-  VERSION = "0.5.3"
+  VERSION = "0.5.4"
 
   ###################################################
   # PNG international standard defined constants

data/lib/chunky_png/canvas.rb

@@ -108,6 +108,15 @@ module ChunkyPNG
     def [](x, y)
       @pixels[y * width + x]
     end
+    
+    # Checks whether the given coordinates are in the range of the canvas
+    # @param [Integer] x The x-coordinate of the pixel (column)
+    # @param [Integer] y The y-coordinate of the pixel (row)
+    # @return [true, false] True if the x and y coordinate are in the range 
+    #    of this canvas.
+    def include?(x, y)
+      (0...width).include?(x) && (0...height).include?(y)
+    end
 
     # Returns the palette used for this canvas.
     # @return [ChunkyPNG::Palette] A pallete which contains all the colors that are
@@ -131,7 +140,8 @@ module ChunkyPNG
     # EXPORTING
     #################################################################
 
-    # Creates an ChunkyPNG::Image object from this canvas
+    # Creates an ChunkyPNG::Image object from this canvas.
+    # @return [ChunkyPNG::Image] This canvas wrapped in an Image instance.
     def to_image
       ChunkyPNG::Image.from_canvas(self)
     end

data/lib/chunky_png/canvas/drawing.rb

@@ -3,6 +3,66 @@ module ChunkyPNG
     
     module Drawing
       
+      # Sets a point on the canvas by composing a pixel with its background color.
+      def point(x, y, color)
+        self[x, y] = ChunkyPNG::Color.compose(color, self[x, y])
+      end
+      
+      # Draws an anti-aliased line using Xiaolin Wu's algorithm.
+      #
+      def line_xiaolin_wu(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
+        
+        if dy == 0 # vertical line
+          Range.new(*[x0,x1].sort).each do |x|
+            point(x, y0, color)
+          end
+        elsif dx == 0 # horizontal line
+          (y0..y1).each do |y|
+            point(x0, y, color)
+          end
+        elsif dx == dy # diagonal
+          x0.step(x1, sx) do |x|
+            point(x, y0, color)
+            y0 += 1
+          end
+          
+        elsif dy > dx  # vertical displacement
+          point(x0, y0, color)
+          e_acc = 0          
+          e = ((dx << 16) / dy.to_f).round
+          (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, ChunkyPNG::Color.fade(color, w)) if include?(x0, y0)
+            y0 = y0 + 1
+            point(x0 + sx, y0, ChunkyPNG::Color.fade(color, 0xff - w)) if include?(x0 + sx, y0)
+          end
+          point(x1, y1, color)
+          
+        else # horizontal displacement
+          point(x0, y0, color)
+          e_acc = 0
+          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, ChunkyPNG::Color.fade(color, w)) if include?(x0, y0)
+            x0 += sx
+            point(x0, y0 + 1, ChunkyPNG::Color.fade(color, 0xff - w)) if include?(x0, y0 + 1)
+          end
+          point(x1, y1, color)
+        end
+      end
+      
+      alias :line :line_xiaolin_wu
+      
     end
   end
 end

data/lib/chunky_png/canvas/png_encoding.rb

@@ -141,7 +141,8 @@ module ChunkyPNG
       end
 
       # Passes to this canvas of pixel values line by line.
-      # @yield [Array<Fixnum>] An line of fixnums reprsenting pixels
+      # @yield [line] Yields the scanlines of this image one by one.
+      # @yieldparam [Array<Fixnum>] line An line of fixnums representing pixels
       def each_scanline(&block)
         for line_no in 0...height do
           scanline = pixels[width * line_no, width]

data/lib/chunky_png/chunk.rb

@@ -9,6 +9,8 @@ module ChunkyPNG
   # represented by the {ChunkyPNG::Chunk::Header} class. These specialized
   # classes help accessing the content of the chunk. All other chunks are
   # represented by the {ChunkyPNG::Chunk::Generic} class.
+  #
+  # @see ChunkyPNG::Datastream
   module Chunk
 
     # Reads a chunk from an IO stream.
@@ -37,37 +39,79 @@ module ChunkyPNG
       raise "Chuck CRC mismatch!" if found_crc != expected_crc
     end
 
+    # The base chunk class is the superclass for every chunk type. It contains
+    # methods to write the chunk to an output stream.
+    #
+    # A subclass should implement the +content+ method, which gets called when
+    # the chunk gets written to a PNG datastream
+    #
+    # @abstract
     class Base
+      
+      # The four-character type indicator for the chunk. This field is used to
+      # find the correct class for a chunk when it is loaded from a PNG stream.
+      # @return [String]
       attr_accessor :type
 
+      # Initializes the chunk instance.
+      # @param [String] type The four character chunk type indicator.
+      # @param [Hash] attributes A hash of attributes to set on this chunk.
       def initialize(type, attributes = {})
         self.type = type
         attributes.each { |k, v| send("#{k}=", v) }
       end
 
+      # Writes the chunk to the IO stream, using the provided content.
+      # The checksum will be calculated and appended to the stream.
+      # @param [IO] io The IO stream to write to.
+      # @param [String] content The content for this chunk.
       def write_with_crc(io, content)
         io << [content.length].pack('N') << type << content
         io << [Zlib.crc32(content, Zlib.crc32(type))].pack('N')
       end
 
+      # Writes the chunk to the IO stream.
+      #
+      # It will call te +content+ method to get the content for this chunk,
+      # and will calculate and append the checksum automatically.
+      # @param [IO] io The IO stream to write to.
       def write(io)
         write_with_crc(io, content || '')
       end
     end
 
+    # The Generic chunk type will read the content from the chunk as it, 
+    # and will write it back as it was read.
     class Generic < Base
 
+      # The attribute to store the content from the chunk, which gets 
+      # written by the +write+ method.
       attr_accessor :content
 
+      
       def initialize(type, content = '')
         super(type, :content => content)
       end
 
+      # Creates an instance, given the chunk's type and content.
+      # @param [String] type The four character chunk type indicator.
+      # @param [String] content The content read from the chunk.
+      # @return [ChunkyPNG::Chunk::Generic] The new chunk instance.
       def self.read(type, content)
         self.new(type, content)
       end
     end
 
+    # The header (IHDR) chunk is the first chunk of every PNG image, and 
+    # contains information about the image: i.e. its width, height, color 
+    # depth, color mode, compression method, filtering method and interlace
+    # method.
+    #
+    # ChunkyPNG supports all values for these variables that are defined in
+    # the PNG spec, except for color depth: Only 8-bit depth images are
+    # supported. Note that it is still possible to access the chunk for such
+    # an image, but ChunkyPNG will raise an exception if you try to access
+    # the pixel data.
     class Header < Base
 
       attr_accessor :width, :height, :depth, :color, :compression, :filtering, :interlace
@@ -81,35 +125,63 @@ module ChunkyPNG
         @interlace   ||= ChunkyPNG::INTERLACING_NONE
       end
 
+      # Reads the 13 bytes of content from the header chunk to set the image attributes.
+      # @param [String] type The four character chunk type indicator (= "IHDR").
+      # @param [String] content The 13 bytes of content read from the chunk.
+      # @return [ChunkyPNG::Chunk::End] The new Header chunk instance with the 
+      #    variables set to the values according to the content.
       def self.read(type, content)
         fields = content.unpack('NNC5')
         self.new(:width => fields[0],  :height => fields[1], :depth => fields[2], :color => fields[3],
                        :compression => fields[4], :filtering => fields[5], :interlace => fields[6])
       end
 
+      # Returns the content for this chunk when it gets written to a file, by packing the
+      # image information variables into the correct format.
+      # @return [String] The 13-byte content for the header chunk.
       def content
         [width, height, depth, color, compression, filtering, interlace].pack('NNC5')
       end
     end
 
+    # The End (IEND) chunk indicates the last chunk of a PNG stream. It does not
+    # contain any data.
     class End < Base
+      
       def initialize
         super('IEND')
       end
-
+      
+      # Reads the END chunk. It will check if the content is empty.
+      # @param [String] type The four character chunk type indicator (= "IEND").
+      # @param [String] content The content read from the chunk. Should be empty.
+      # @return [ChunkyPNG::Chunk::End] The new End chunk instance.
+      # @raise [RuntimeError] Raises an exception if the content was not empty.
       def self.read(type, content)
         raise 'The IEND chunk should be empty!' if content != ''
         self.new
       end
 
+      # Returns an empty string, because this chunk should always be empty.
+      # @return [""] An empty string.
       def content
         ''
       end
     end
 
+    # The Palette (PLTE) chunk contains the image's palette, i.e. the
+    # 8-bit RGB colors this image is using.
+    #
+    # @see ChunkyPNG::Chunk::Transparency
+    # @see ChunkyPNG::Palette 
     class Palette < Generic
     end
 
+    # A transparency (tRNS) chunk contains the alpha channel for the colors 
+    # defined in the Palette (PLTE) chunk
+    #
+    # @see ChunkyPNG::Chunk::Palette
+    # @see ChunkyPNG::Palette
     class Transparency < Generic
     end
 
@@ -126,6 +198,14 @@ module ChunkyPNG
       end
     end
 
+    # The Text (tEXt) chunk contains keyword/value metadata about the PNG stream.
+    # In this chunk, the value is stored uncompressed.
+    #
+    # The tEXt chunk only supports Latin-1 encoded textual data. If you need UTF-8 
+    # support, check out the InternationalText chunk type.
+    #
+    # @see ChunkyPNG::Chunk::CompressedText
+    # @see ChunkyPNG::Chunk::InternationalText
     class Text < Base
 
       attr_accessor :keyword, :value
@@ -140,17 +220,27 @@ module ChunkyPNG
         new(keyword, value)
       end
 
+      # Creates the content to write to the stream, by concatenating the keyword
+      # with the value, joined by a null character.
+      #
+      # @return The content that should be written to the datastream.
       def content
         [keyword, value].pack('Z*a*')
       end
     end
 
+    # The CompressedText (zTXt) chunk contains keyword/value metadata about 
+    # the PNG stream. In this chunk, the value is compressed using Deflate
+    # compression.
+    #
+    # @see ChunkyPNG::Chunk::CompressedText
+    # @see ChunkyPNG::Chunk::InternationalText
     class CompressedText < Base
 
       attr_accessor :keyword, :value
 
       def initialize(keyword, value)
-        super('tEXt')
+        super('zTXt')
         @keyword, @value = keyword, value
       end
 
@@ -160,17 +250,37 @@ module ChunkyPNG
         new(keyword, Zlib::Inflate.inflate(value))
       end
 
+      # Creates the content to write to the stream, by concatenating the keyword
+      # with the deflated value, joined by a null character.
+      #
+      # @return The content that should be written to the datastream.
       def content
         [keyword, ChunkyPNG::COMPRESSION_DEFAULT, Zlib::Deflate.deflate(value)].pack('Z*Ca*')
       end
     end
 
+    # The Text (iTXt) chunk contains keyword/value metadata about the PNG stream.
+    # The metadata in this chunk can be encoded using UTF-8 characters. Moreover,
+    # it is possible to define the language of the metadata, and give a translation
+    # of the keyword name. Finally, it supports bot compressed and uncompressed
+    # values.
+    # 
+    # @todo This chunk is currently not implemented, but merely read and written 
+    #    back intact.
+    #
+    # @see ChunkyPNG::Chunk::Text
+    # @see ChunkyPNG::Chunk::CompressedText
     class InternationalText < Generic
+      
       # TODO
     end
 
-    # Maps chunk types to classes.
-    # If a chunk type is not given in this hash, a generic chunk type will be used.
+    # Maps chunk types to classes, based on the four byte chunk type indicator at the
+    # beginning of a chunk.
+    #
+    # If a chunk type is not specified in this hash, the Generic chunk type will be used.
+    #
+    # @see ChunkyPNG::Chunk.read
     CHUNK_TYPES = {
       'IHDR' => Header, 'IEND' => End, 'IDAT' => ImageData, 'PLTE' => Palette, 'tRNS' => Transparency,
       'tEXt' => Text, 'zTXt' => CompressedText, 'iTXt' => InternationalText

data/lib/chunky_png/color.rb

@@ -46,7 +46,7 @@ module ChunkyPNG
     def grayscale_alpha(teint, a)
       teint << 24 | teint << 16 | teint << 8 | a
     end
-    
+
     ####################################################################
     # COLOR IMPORTING
     ####################################################################
@@ -222,6 +222,15 @@ module ChunkyPNG
       (fg + bg) >> 1
     end
 
+    # Lowers the intensity of a color, by lowering its alpha by a given factor.
+    # @param [Fixnum] color The color to adjust.
+    # @param [Fixnum] factor Fade factor as an integer between 0 and 255.
+    # @return [Fixnum] The faded color.
+    def fade(color, factor)
+      new_alpha = int8_mult(a(color), factor)
+      (color & 0xffffff00) | new_alpha
+    end
+
     ####################################################################
     # CONVERSIONS
     ####################################################################

data/lib/chunky_png/datastream.rb

@@ -44,9 +44,9 @@ module ChunkyPNG
       @data_chunks  = []
     end
 
-    #############################################
+    ##############################################################################
     # LOADING DATASTREAMS
-    #############################################
+    ##############################################################################
 
     class << self
 
@@ -102,16 +102,17 @@ module ChunkyPNG
       end
     end
 
-    #############################################
+    ##################################################################################
     # CHUNKS
-    #############################################
+    ##################################################################################
 
     # Enumerates the chunks in this datastream.
     #
     # This will iterate over the chunks using the order in which the chunks
     # should appear in the PNG file.
     #
-    # @yield [ChunkyPNG::Chunk::Base] The chunks in this datastrean, one by one.
+    # @yield [chunk] Yields the chunks in this datastrean, one by one in the correct order.
+    # @yieldparam [ChunkyPNG::Chunk::Base] chunk A chunk in this datastream.
     # @see ChunkyPNG::Datastream#chunks
     def each_chunk
       yield(header_chunk)
@@ -138,9 +139,9 @@ module ChunkyPNG
       metadata
     end
 
-    #############################################
+    ##################################################################################
     # WRITING DATASTREAMS
-    #############################################
+    ##################################################################################
 
     # Writes the datastream to the given output stream.
     # @param [IO] io The output stream to write to.

data/lib/chunky_png/rmagick.rb

@@ -9,7 +9,7 @@ module ChunkyPNG
   #
   # @example
   #
-  #    require 'rmagick
+  #    require 'rmagick'
   #    require 'chunky_png/rmagick'
   #    
   #    canvas = ChunkyPNG::Canvas.from_file('filename.png')

data/spec/chunky_png/canvas/drawing_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Canvas::Drawing do
+  
+  describe '#point' do
+    it "should compose colors correctly" do
+      canvas = ChunkyPNG::Canvas.new(1, 1, ChunkyPNG::Color.rgb(200, 150, 100))
+      canvas.point(0,0, ChunkyPNG::Color.rgba(100, 150, 200, 128))
+      canvas[0,0].should == ChunkyPNG::Color.rgb(150, 150, 150)
+    end
+  end
+  
+  describe '#line' do
+    it "should draw lines correctly with anti-aliasing" do
+      canvas = ChunkyPNG::Canvas.new(32, 32, ChunkyPNG::Color::WHITE)
+      
+      canvas.line( 0,  0, 31, 31, ChunkyPNG::Color::BLACK)
+      canvas.line( 0, 31, 31,  0, ChunkyPNG::Color::BLACK)
+      canvas.line(15, 31, 15,  0, ChunkyPNG::Color.rgba(200,   0,   0, 128))
+      canvas.line( 0, 15, 31, 15, ChunkyPNG::Color.rgba(200,   0,   0, 128))
+      canvas.line( 0, 15, 31, 31, ChunkyPNG::Color.rgba(  0, 200,   0, 128))
+      canvas.line( 0, 15, 31,  0, ChunkyPNG::Color.rgba(  0, 200,   0, 128))
+      canvas.line(15,  0, 31, 31, ChunkyPNG::Color.rgba(  0,   0, 200, 128))
+      canvas.line(15,  0,  0, 31, ChunkyPNG::Color.rgba(  0,   0, 200, 128))
+      
+      canvas.should == reference_canvas('lines')
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: chunky_png
 version: !ruby/object:Gem::Version 
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-17 00:00:00 +01:00
+date: 2010-01-18 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -69,11 +69,13 @@ files:
 - spec/resources/gray_10x10_indexed.png
 - spec/resources/16x16_non_interlaced.png
 - spec/chunky_png_spec.rb
+- spec/chunky_png/canvas/drawing_spec.rb
 - lib/chunky_png/palette.rb
 - lib/chunky_png/datastream.rb
 - chunky_png.gemspec
 - tasks/github-gem.rake
 - spec/resources/pixelstream_reference.png
+- spec/resources/lines.png
 - spec/resources/gray_10x10_grayscale_alpha.png
 - spec/resources/16x16_interlaced.png
 - spec/chunky_png/image_spec.rb
@@ -125,6 +127,7 @@ test_files:
 - spec/chunky_png/canvas/adam7_interlacing_spec.rb
 - spec/chunky_png/canvas/png_decoding_spec.rb
 - spec/chunky_png_spec.rb
+- spec/chunky_png/canvas/drawing_spec.rb
 - spec/chunky_png/image_spec.rb
 - spec/chunky_png/rmagick_spec.rb
 - spec/chunky_png/datastream_spec.rb