chunky_png 0.0.1 → 0.0.2

data/.gitignore

@@ -1,2 +1,4 @@
 .DS_Store
 spec/resources/testing.png
+/pkg
+/tmp

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.0.1"
-  s.date    = "2010-01-10"
+  s.version = "0.0.2"
+  s.date    = "2010-01-12"
 
   s.summary     = "Pure ruby library for read/write, chunk-level access to PNG files"
   s.description = "Pure ruby library for read/write, chunk-level access to PNG files"
@@ -20,6 +20,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 .gitignore lib/chunky_png/pixel_matrix.rb LICENSE lib/chunky_png/chunk.rb Rakefile README.rdoc spec/resources/indexed_10x10.png spec/integration/image_spec.rb lib/chunky_png/palette.rb lib/chunky_png/datastream.rb chunky_png.gemspec tasks/github-gem.rake lib/chunky_png/image.rb spec/unit/pixel_matrix_spec.rb lib/chunky_png.rb)
-  s.test_files = %w(spec/integration/image_spec.rb spec/unit/pixel_matrix_spec.rb)
+  s.files      = %w(spec/spec_helper.rb spec/resources/gray_10x10_grayscale.png spec/resources/gray_10x10.png .gitignore spec/resources/gray_10x10_truecolor_alpha.png lib/chunky_png/pixel_matrix.rb LICENSE spec/resources/gray_10x10_truecolor.png lib/chunky_png/pixel_matrix/decoding.rb lib/chunky_png/chunk.rb spec/unit/encoding_spec.rb Rakefile README.rdoc spec/resources/gray_10x10_indexed.png spec/integration/image_spec.rb lib/chunky_png/pixel.rb lib/chunky_png/palette.rb lib/chunky_png/datastream.rb chunky_png.gemspec tasks/github-gem.rake spec/unit/decoding_spec.rb spec/resources/gray_10x10_grayscale_alpha.png lib/chunky_png/pixel_matrix/encoding.rb lib/chunky_png/image.rb spec/unit/pixel_spec.rb spec/unit/pixel_matrix_spec.rb lib/chunky_png.rb)
+  s.test_files = %w(spec/unit/encoding_spec.rb spec/integration/image_spec.rb spec/unit/decoding_spec.rb spec/unit/pixel_spec.rb spec/unit/pixel_matrix_spec.rb)
 end

data/lib/chunky_png.rb

@@ -4,6 +4,9 @@ require 'zlib'
 require 'chunky_png/datastream'
 require 'chunky_png/chunk'
 require 'chunky_png/palette'
+require 'chunky_png/pixel'
+require 'chunky_png/pixel_matrix/encoding'
+require 'chunky_png/pixel_matrix/decoding'
 require 'chunky_png/pixel_matrix'
 require 'chunky_png/image'
 

data/lib/chunky_png/chunk.rb

@@ -90,6 +90,9 @@ module ChunkyPNG
 
     class Palette < Generic
     end
+    
+    class Transparency < Generic
+    end
 
     class ImageData < Generic
     end
@@ -97,7 +100,7 @@ module ChunkyPNG
     # Maps chunk types to classes.
     # If a chunk type is not given in this hash, a generic chunk type will be used.
     CHUNK_TYPES = {
-      'IHDR' => Header, 'IEND' => End, 'IDAT' => ImageData, 'PLTE' => Palette
+      'IHDR' => Header, 'IEND' => End, 'IDAT' => ImageData, 'PLTE' => Palette, 'tRNS' => Transparency
     }
     
   end

data/lib/chunky_png/datastream.rb

@@ -7,6 +7,7 @@ module ChunkyPNG
     attr_accessor :header_chunk
     attr_accessor :other_chunks
     attr_accessor :palette_chunk
+    attr_accessor :transparency_chunk
     attr_accessor :data_chunks
     attr_accessor :end_chunk
 
@@ -17,10 +18,11 @@ module ChunkyPNG
       until io.eof?
         chunk = ChunkyPNG::Chunk.read(io)
         case chunk
-          when ChunkyPNG::Chunk::Header    then ds.header_chunk  = chunk
-          when ChunkyPNG::Chunk::Palette   then ds.palette_chunk = chunk
-          when ChunkyPNG::Chunk::ImageData then ds.data_chunks  << chunk
-          when ChunkyPNG::Chunk::End       then ds.end_chunk     = chunk
+          when ChunkyPNG::Chunk::Header       then ds.header_chunk        = chunk
+          when ChunkyPNG::Chunk::Palette      then ds.palette_chunk       = chunk
+          when ChunkyPNG::Chunk::Transparency then ds.transparency_chunk  = chunk
+          when ChunkyPNG::Chunk::ImageData    then ds.data_chunks        << chunk
+          when ChunkyPNG::Chunk::End          then ds.end_chunk           = chunk
           else ds.other_chunks << chunk
         end
       end
@@ -35,7 +37,8 @@ module ChunkyPNG
     def chunks
       cs = [header_chunk]
       cs += other_chunks
-      cs << palette_chunk if palette_chunk
+      cs << palette_chunk      if palette_chunk
+      cs << transparency_chunk if transparency_chunk
       cs += data_chunks
       cs << end_chunk
       return cs
@@ -62,11 +65,7 @@ module ChunkyPNG
     end
     
     def pixel_matrix
-      @pixel_matrix ||= begin
-        data = data_chunks.map(&:content).join('')
-        streamdata = Zlib::Inflate.inflate(data)
-        matrix     = ChunkyPNG::PixelMatrix.load(header, streamdata)
-      end
+      @pixel_matrix ||= ChunkyPNG::PixelMatrix.decode(self)
     end
   end
 end

data/lib/chunky_png/image.rb

@@ -3,7 +3,7 @@ module ChunkyPNG
     
     attr_reader :pixels
     
-    def initialize(width, height, background_color = ChunkyPNG::Color::WHITE)
+    def initialize(width, height, background_color = ChunkyPNG::Pixel::TRANSPARENT)
       @pixels = ChunkyPNG::PixelMatrix.new(width, height, background_color)
     end
     
@@ -15,22 +15,8 @@ module ChunkyPNG
       pixels.height
     end
     
-    def write(io)
-      datastream = ChunkyPNG::Datastream.new
-
-      palette = pixels.palette
-      if palette.indexable?
-        datastream.header_chunk = ChunkyPNG::Chunk::Header.new(:width => width, :height => height, :color => ChunkyPNG::Chunk::Header::COLOR_INDEXED)
-        datastream.palette_chunk = palette.to_plte_chunk
-        datastream.data_chunks  = datastream.idat_chunks(pixels.to_indexed_pixelstream(palette))
-        datastream.end_chunk    = ChunkyPNG::Chunk::End.new
-      else
-        raise 'd'
-        datastream.header_chunk = ChunkyPNG::Chunk::Header.new(:width => width, :height => height)
-        datastream.data_chunks  = datastream.idat_chunks(pixels.to_rgb_pixelstream)
-        datastream.end_chunk    = ChunkyPNG::Chunk::End.new
-      end
-      
+    def write(io, constraints = {})
+      datastream = pixels.to_datastream(constraints)
       datastream.write(io)
     end
   end

data/lib/chunky_png/palette.rb

@@ -4,88 +4,92 @@ module ChunkyPNG
   # PALETTE CLASS
   ###########################################
   
-  class Palette < Set
+  class Palette < SortedSet
     
-    def self.from_pixel_matrix(pixel_matrix)
-      from_pixels(pixel_matrix.pixels)
+    def initialize(enum)
+      super(enum)
+      @decoding_map = enum if enum.kind_of?(Array)
     end
     
-    def self.from_pixels(pixels)
-      from_colors(pixels.map(&:color))
+    def self.from_chunks(palette_chunk, transparency_chunk = nil)
+      return nil if palette_chunk.nil?
+      
+      decoding_map = []
+      index = 0
+      
+      palatte_bytes = palette_chunk.content.unpack('C*')
+      if transparency_chunk
+        alpha_channel = transparency_chunk.content.unpack('C*')
+      else
+        alpha_channel = Array.new(palatte_bytes.size / 3, 255)
+      end
+      
+      index = 0
+      palatte_bytes.each_slice(3) do |bytes|
+        bytes << alpha_channel[index]
+        decoding_map << ChunkyPNG::Pixel.rgba(*bytes)
+        index += 1
+      end
+      
+      self.new(decoding_map)
+    end
+    
+    def self.from_pixel_matrix(pixel_matrix)
+      self.new(pixel_matrix.pixels)
     end
     
-    def self.from_colors(colors)
-      palette = self.new
-      colors.each { |color| palette << color }
-      palette
+    def self.from_pixels(pixels)
+      self.new(pixels)
     end
     
     def indexable?
       size < 256
     end
     
+    def opaque?
+      all? { |pixel| pixel.opaque? }
+    end
+
+    def can_decode?
+      !@decoding_map.nil?
+    end
+    
+    def can_encode?
+      !@encoding_map.nil?
+    end
+    
+    def [](index)
+      @decoding_map[index]
+    end
+    
     def index(color)
-      @color_map[color]
+      @encoding_map[color]
+    end
+    
+    def to_trns_chunk
+      ChunkyPNG::Chunk::Transparency.new('tRNS', map(&:a).pack('C*'))
     end
     
     def to_plte_chunk
-      @color_map = {}
+      @encoding_map = {}
       colors     = []
       
       each_with_index do |color, index|
-        @color_map[color] = index
-        colors += color.to_rgb_array
+        @encoding_map[color] = index
+        colors += color.to_truecolor_bytes
       end
       
-      ChunkyPNG::Chunk::Generic.new('PLTE', colors.pack('C*'))
-    end
-  end
-  
-  ###########################################
-  # COLOR CLASS
-  ###########################################
-  
-  class Color
-    
-    attr_accessor :r, :g, :b
-
-    def initialize(r, g, b)
-      @r, @g, @b = r, g, b
-    end
-
-    ### CONSTRUCTORS ###########################################
-
-    def self.rgb(r, g, b)
-      new(r, g, b)
-    end
-
-    ### COLOR CONSTANTS ###########################################
-
-    BLACK = rgb(  0,   0,   0)
-    WHITE = rgb(255, 255, 255)
-
-    ### CONVERSION ###########################################
-
-    def index(palette)
-      palette.index(self)
-    end
-
-    def to_rgb_array
-      [r, g, b]
-    end
-
-    def to_rgb
-      to_rgb_array.pack('CCC')
-    end
-
-    def inspect
-      '#%02x%02x%02x' % [r, g, b]
+      ChunkyPNG::Chunk::Palette.new('PLTE', colors.pack('C*'))
     end
     
-    ### EQUALITY ###########################################
-    
-    def ==(other)
-      other.kind_of?(self.class) && to_rgb_array == other.to_rgb_array
+    def best_colormode
+      if indexable?
+        ChunkyPNG::Chunk::Header::COLOR_INDEXED
+      elsif opaque?
+        ChunkyPNG::Chunk::Header::COLOR_TRUECOLOR
+      else
+        ChunkyPNG::Chunk::Header::COLOR_TRUECOLOR_ALPHA
+      end
     end
   end
 end

data/lib/chunky_png/pixel.rb

@@ -0,0 +1,101 @@
+module ChunkyPNG
+
+  class Pixel
+        
+    attr_reader :value
+    
+    def initialize(value)
+      @value = value
+    end
+
+    def self.rgb(r, g, b)
+      rgba(r, g, b, 255)
+    end
+    
+    def self.rgba(r, g, b, a)
+      new(r << 24 | g << 16 | b << 8 | a)
+    end
+    
+    def self.grayscale(teint, a = 255)
+      rgba(teint, teint, teint, a)
+    end
+    
+    def self.from_rgb_stream(stream)
+      self.rgb(*stream.unpack('C3'))
+    end
+
+    def self.from_rgba_stream(stream)
+      self.rgba(*stream.unpack('C4'))
+    end
+    
+    def r
+      (@value & 0xff000000) >> 24
+    end
+
+    def g
+      (@value & 0x00ff0000) >> 16
+    end
+
+    def b
+      (@value & 0x0000ff00) >> 8
+    end
+
+    def a
+      @value & 0x000000ff
+    end
+    
+    def opaque?
+      a == 0x000000ff
+    end
+    
+    def inspect
+      '#%08x' % @value
+    end
+    
+    def eql?(other)
+      other.kind_of?(self.class) && other.value == self.value
+    end
+    
+    alias :== :eql?
+    
+    def to_truecolor_alpha_bytes
+      [r,g,b,a]
+    end
+
+    def to_truecolor_bytes
+      [r,g,b]
+    end
+    
+    def index(palette)
+      palette.index(self)
+    end
+    
+    def to_indexed_bytes(palette)
+      [index(palette)]
+    end
+    
+    def to_grayscale_bytes
+      [r] # Assumption: r == g == b
+    end
+
+    def to_grayscale_alpha_bytes
+      [r, a] # Assumption: r == g == b
+    end
+    
+    BLACK = rgb(  0,   0,   0)
+    WHITE = rgb(255, 255, 255)
+    
+    TRANSPARENT = rgba(0, 0, 0, 0)
+    
+    def self.bytesize(color_mode)
+      case color_mode
+        when ChunkyPNG::Chunk::Header::COLOR_INDEXED         then 1
+        when ChunkyPNG::Chunk::Header::COLOR_TRUECOLOR       then 3
+        when ChunkyPNG::Chunk::Header::COLOR_TRUECOLOR_ALPHA then 4
+        when ChunkyPNG::Chunk::Header::COLOR_GRAYSCALE       then 1
+        when ChunkyPNG::Chunk::Header::COLOR_GRAYSCALE_ALPHA then 2
+        else raise "Don't know the bytesize of pixels in this colormode: #{color_mode}!"
+      end
+    end
+  end
+end

data/lib/chunky_png/pixel_matrix.rb

@@ -2,6 +2,9 @@ module ChunkyPNG
   
   class PixelMatrix
     
+    include Encoding
+    extend  Decoding
+    
     FILTER_NONE    = 0
     FILTER_SUB     = 1
     FILTER_UP      = 2
@@ -9,11 +12,23 @@ module ChunkyPNG
     FILTER_PAETH   = 4
     
     attr_reader :width, :height, :pixels
+
+
+    def initialize(width, height, initial = ChunkyPNG::Pixel::TRANSPARENT)
+      
+      @width, @height = width, height
+      
+      if initial.kind_of?(ChunkyPNG::Pixel)
+        @pixels = Array.new(width * height, initial)
+      elsif initial.kind_of?(Array) && initial.size == width * height
+        @pixels = initial
+      else 
+        raise "Cannot use this value as initial pixel matrix: #{initial.inspect}!"
+      end
+    end
     
-    def self.load(header, content)
-      matrix = self.new(header.width, header.height)
-      matrix.decode_pixelstream(content, header)
-      return matrix
+    def []=(x, y, pixel)
+      @pixels[y * width + x] = pixel
     end
     
     def [](x, y)
@@ -27,131 +42,34 @@ module ChunkyPNG
       end
     end
     
-    def []=(x, y, color)
-      @pixels[y * width + x] = Pixel.new(color)
-    end
-    
-    def initialize(width, height, background_color = ChunkyPNG::Color::WHITE)
-      @width, @height = width, height
-      @pixels = Array.new(width * height, Pixel.new(background_color))
-    end
-
-    def decode_pixelstream(stream, header = nil)
-      verify_length!(stream.length)
-      @pixels = []
-      
-      decoded_bytes = Array.new(header.width * 3, 0)
-      height.times do |line_no|
-        position       = line_no * (width * 3 + 1)
-        line_length    = header.width * 3
-        bytes          = stream.unpack("@#{position}CC#{line_length}")
-        filter         = bytes.shift
-        decoded_bytes  = decode_scanline(filter, bytes, decoded_bytes, header)
-        decoded_colors = decode_colors(decoded_bytes, header)
-        @pixels += decoded_colors.map { |c| Pixel.new(c) }
-      end
-      
-      raise "Invalid amount of pixels" if @pixels.size != width * height
-    end
-    
-    def decode_colors(bytes, header)
-      (0...width).map { |i| ChunkyPNG::Color.rgb(bytes[i*3+0], bytes[i*3+1], bytes[i*3+2]) }
-    end
-    
-    def decode_scanline(filter, bytes, previous_bytes, header = nil)
-      case filter
-      when FILTER_NONE    then decode_scanline_none( bytes, previous_bytes, header)
-      when FILTER_SUB     then decode_scanline_sub(  bytes, previous_bytes, header)
-      when FILTER_UP      then decode_scanline_up(   bytes, previous_bytes, header)
-      when FILTER_AVERAGE then raise "Average filter are not yet supported!"
-      when FILTER_PAETH   then raise "Paeth filter are not yet supported!"
-      else raise "Unknown filter type"
-      end
-    end
-    
-    def decode_scanline_none(bytes, previous_bytes, header = nil)
-      bytes
-    end
-    
-    def decode_scanline_sub(bytes, previous_bytes, header = nil)
-      bytes.each_with_index { |b, i| bytes[i] = (b + (i >= 3 ? bytes[i-3] : 0)) % 256 }
-      bytes
-    end
-    
-    def decode_scanline_up(bytes, previous_bytes, header = nil)
-      bytes.each_with_index { |b, i| bytes[i] = (b + previous_bytes[i]) % 256 }
-      bytes
-    end
-    
-    def verify_length!(bytes_count)
-      raise "Invalid stream length!" unless bytes_count == width * height * 3 + height
-    end
-    
-    def encode_scanline(filter, bytes, previous_bytes, header = nil)
-      case filter
-      when FILTER_NONE    then encode_scanline_none( bytes, previous_bytes, header)
-      when FILTER_SUB     then encode_scanline_sub(  bytes, previous_bytes, header)
-      when FILTER_UP      then encode_scanline_up(   bytes, previous_bytes, header)
-      when FILTER_AVERAGE then raise "Average filter are not yet supported!"
-      when FILTER_PAETH   then raise "Paeth filter are not yet supported!"
-      else raise "Unknown filter type"
-      end
-    end
-    
-    def encode_scanline_none(bytes, previous_bytes, header = nil)
-      [FILTER_NONE] + bytes
-    end
-    
-    def encode_scanline_sub(bytes, previous_bytes, header = nil)
-      encoded = (3...bytes.length).map { |n| (bytes[n-3] - bytes[n]) % 256 }
-      [FILTER_SUB] + bytes[0...3] + encoded
-    end
-    
-    def encode_scanline_up(bytes, previous_bytes, header = nil)
-      encoded = (0...bytes.length).map { |n| previous_bytes[n] - bytes[n] % 256 }
-      [FILTER_UP] + encoded
-    end
-    
     def palette
       ChunkyPNG::Palette.from_pixels(@pixels)
     end
     
-    def indexable?
-      palette.indexable?
-    end
-    
-    def to_indexed_pixelstream(palette)
-      stream = ""
-      each_scanline do |line|
-        bytes  = line.map { |p| p.color.index(palette) }
-        stream << encode_scanline(FILTER_NONE, bytes, nil, nil).pack('C*')
-      end
-      return stream
+    def opaque?
+      pixels.all? { |pixel| pixel.opaque? }
     end
     
-    def to_rgb_pixelstream
-      stream = ""
-      each_scanline do |line|
-        bytes = line.map { |p| p.color.to_rgb_array }.flatten
-        stream << encode_scanline(FILTER_NONE, bytes, nil, nil).pack('C*')
-      end
-      return stream
+    def indexable?
+      palette.indexable?
     end
-  end
-  
-  class Pixel
-    attr_accessor :color, :alpha
     
-    def initialize(color, alpha = 255)
-      @color, @alpha = color, alpha
+    def to_datastream(constraints = {})
+      data = encode(constraints)
+      ds = Datastream.new
+      ds.header_chunk       = Chunk::Header.new(data[:header])
+      ds.palette_chunk      = data[:palette_chunk]      if data[:palette_chunk]
+      ds.transparency_chunk = data[:transparency_chunk] if data[:transparency_chunk]
+      ds.data_chunks        = ds.idat_chunks(data[:pixelstream])
+      ds.end_chunk          = Chunk::End.new
+      return ds
     end
     
-    def opaque?
-      alpha == 255
+    def eql?(other)
+      other.kind_of?(self.class) && other.pixels == self.pixels &&
+            other.width == self.width && other.height == self.height
     end
     
-    def make_opaque!
-      alpha = 255
-    end
+    alias :== :eql?
   end
 end

data/lib/chunky_png/pixel_matrix/decoding.rb

@@ -0,0 +1,75 @@
+module ChunkyPNG
+  class PixelMatrix
+    module Decoding
+      
+      def decode(ds)
+        stream     = Zlib::Inflate.inflate(ds.data_chunks.map(&:content).join(''))
+        width      = ds.header_chunk.width
+        height     = ds.header_chunk.height
+        color_mode = ds.header_chunk.color
+        palette    = ChunkyPNG::Palette.from_chunks(ds.palette_chunk, ds.transparency_chunk)
+        decode_pixelstream(stream, width, height, color_mode, palette)
+      end
+      
+      def decode_pixelstream(stream, width, height, color_mode = ChunkyPNG::Chunk::Header::COLOR_TRUECOLOR, palette = nil)
+
+        pixel_size = Pixel.bytesize(color_mode)
+        raise "Invalid stream length!" unless stream.length == width * height * pixel_size + height
+        raise "This palette is not suitable for decoding!" if palette && !palette.can_decode?
+
+        pixel_decoder = case color_mode
+          when ChunkyPNG::Chunk::Header::COLOR_TRUECOLOR       then lambda { |bytes| ChunkyPNG::Pixel.rgb(*bytes) }
+          when ChunkyPNG::Chunk::Header::COLOR_TRUECOLOR_ALPHA then lambda { |bytes| ChunkyPNG::Pixel.rgba(*bytes) }
+          when ChunkyPNG::Chunk::Header::COLOR_INDEXED         then lambda { |bytes| palette[bytes.first] }
+          when ChunkyPNG::Chunk::Header::COLOR_GRAYSCALE       then lambda { |bytes| ChunkyPNG::Pixel.grayscale(*bytes) }
+          when ChunkyPNG::Chunk::Header::COLOR_GRAYSCALE_ALPHA then lambda { |bytes| ChunkyPNG::Pixel.grayscale(*bytes) }
+          else raise "No suitable pixel decoder found for color mode #{color_mode}!"
+        end
+        
+        pixels = []
+        decoded_bytes = Array.new(width * pixel_size, 0)
+        height.times do |line_no|
+          
+          # get bytes of scanline
+          position       = line_no * (width * pixel_size + 1)
+          line_length    = width * pixel_size
+          bytes          = stream.unpack("@#{position}CC#{line_length}")
+          filter         = bytes.shift
+          decoded_bytes  = decode_scanline(filter, bytes, decoded_bytes, pixel_size)
+          
+          # decode bytes into colors
+          decoded_bytes.each_slice(pixel_size) { |bytes| pixels << pixel_decoder.call(bytes) }
+        end
+        
+        return ChunkyPNG::PixelMatrix.new(width, height, pixels)
+      end
+      
+      protected
+      
+      def decode_scanline(filter, bytes, previous_bytes, pixelsize = 3)
+        case filter
+        when FILTER_NONE    then decode_scanline_none( bytes, previous_bytes, pixelsize)
+        when FILTER_SUB     then decode_scanline_sub(  bytes, previous_bytes, pixelsize)
+        when FILTER_UP      then decode_scanline_up(   bytes, previous_bytes, pixelsize)
+        when FILTER_AVERAGE then raise "Average filter are not yet supported!"
+        when FILTER_PAETH   then raise "Paeth filter are not yet supported!"
+        else raise "Unknown filter type"
+        end
+      end
+
+      def decode_scanline_none(bytes, previous_bytes, pixelsize = 3)
+        bytes
+      end
+
+      def decode_scanline_sub(bytes, previous_bytes, pixelsize = 3)
+        bytes.each_with_index { |b, i| bytes[i] = (b + (i >= pixelsize ? bytes[i-pixelsize] : 0)) % 256 }
+        bytes
+      end
+
+      def decode_scanline_up(bytes, previous_bytes, pixelsize = 3)
+        bytes.each_with_index { |b, i| bytes[i] = (b + previous_bytes[i]) % 256 }
+        bytes
+      end
+    end
+  end
+end

data/lib/chunky_png/pixel_matrix/encoding.rb

@@ -0,0 +1,83 @@
+module ChunkyPNG
+  class PixelMatrix
+    module Encoding
+
+      def encode(constraints = {})
+        encoding = determine_encoding(constraints)
+        result = {}
+        result[:header] = { :width => width, :height => height, :color => encoding[:color_mode] }
+
+        if encoding[:color_mode] == ChunkyPNG::Chunk::Header::COLOR_INDEXED
+          result[:palette_chunk]      = encoding[:palette].to_plte_chunk
+          result[:transparency_chunk] = encoding[:palette].to_trns_chunk unless encoding[:palette].opaque?
+        end
+
+        result[:pixelstream] = encode_pixelstream(encoding[:color_mode], encoding[:palette])
+        return result
+      end
+      
+      protected
+      
+      def determine_encoding(constraints = {})
+        encoding = constraints
+        encoding[:palette]    ||= palette
+        encoding[:color_mode] ||= encoding[:palette].best_colormode
+        return encoding
+      end
+      
+      def encode_pixelstream(color_mode = ChunkyPNG::Chunk::Header::COLOR_TRUECOLOR, palette = nil)
+
+        pixel_encoder = case color_mode
+          when ChunkyPNG::Chunk::Header::COLOR_TRUECOLOR       then lambda { |pixel| pixel.to_truecolor_bytes }
+          when ChunkyPNG::Chunk::Header::COLOR_TRUECOLOR_ALPHA then lambda { |pixel| pixel.to_truecolor_alpha_bytes }
+          when ChunkyPNG::Chunk::Header::COLOR_INDEXED         then lambda { |pixel| pixel.to_indexed_bytes(palette) }
+          when ChunkyPNG::Chunk::Header::COLOR_GRAYSCALE       then lambda { |pixel| pixel.to_grayscale_bytes }
+          when ChunkyPNG::Chunk::Header::COLOR_GRAYSCALE_ALPHA then lambda { |pixel| pixel.to_grayscale_alpha_bytes }
+          else raise "Cannot encode pixels for this mode: #{color_mode}!"
+        end
+        
+        raise "This palette is not suitable for encoding!" if palette && !palette.can_encode?
+
+        pixelsize = Pixel.bytesize(color_mode)
+
+        stream   = ""
+        previous = nil
+        each_scanline do |line|
+          bytes  = line.map(&pixel_encoder).flatten
+          if previous
+            stream << encode_scanline_up(bytes, previous, pixelsize).pack('C*')
+          else
+            stream << encode_scanline_sub(bytes, previous, pixelsize).pack('C*')
+          end
+          previous = bytes
+        end
+        return stream
+      end      
+
+      def encode_scanline(filter, bytes, previous_bytes = nil, pixelsize = 3)
+        case filter
+        when FILTER_NONE    then encode_scanline_none( bytes, previous_bytes, pixelsize)
+        when FILTER_SUB     then encode_scanline_sub(  bytes, previous_bytes, pixelsize)
+        when FILTER_UP      then encode_scanline_up(   bytes, previous_bytes, pixelsize)
+        when FILTER_AVERAGE then raise "Average filter are not yet supported!"
+        when FILTER_PAETH   then raise "Paeth filter are not yet supported!"
+        else raise "Unknown filter type"
+        end
+      end
+
+      def encode_scanline_none(bytes, previous_bytes = nil, pixelsize = 3)
+        [FILTER_NONE] + bytes
+      end
+
+      def encode_scanline_sub(bytes, previous_bytes = nil, pixelsize = 3)
+        encoded = (pixelsize...bytes.length).map { |n| (bytes[n-pixelsize] - bytes[n]) % 256 }
+        [FILTER_SUB] + bytes[0...pixelsize] + encoded
+      end
+
+      def encode_scanline_up(bytes, previous_bytes, pixelsize = 3)
+        encoded = (0...bytes.length).map { |n| previous_bytes[n] - bytes[n] % 256 }
+        [FILTER_UP] + encoded
+      end
+    end
+  end
+end

data/spec/integration/image_spec.rb

@@ -1,22 +1,15 @@
 require File.expand_path('../spec_helper.rb', File.dirname(__FILE__))
 
-describe ChunkyPNG::Image do
-
-  it "should write a valid PNG image using an indexed palette" do
-    image    = ChunkyPNG::Image.new(10, 20, ChunkyPNG::Color.rgb(10, 100, 255))
-    filename = resource_file('testing.png')
-    File.open(filename, 'w') { |f| image.write(f) }
-
-    png = ChunkyPNG.load(filename)
-    png.header_chunk.width.should  == 10
-    png.header_chunk.height.should == 20
-    png.header_chunk.color.should  == ChunkyPNG::Chunk::Header::COLOR_INDEXED
-
-    png.palette_chunk.should_not be_nil
-    png.data_chunks.should_not be_empty
-    # `open #{filename}`
-    
-    File.unlink(filename)
-  end
+describe ChunkyPNG do
+  
+  # it "should create reference images for all color modes" do
+  #   image    = ChunkyPNG::Image.new(10, 10, ChunkyPNG::Pixel.rgb(100, 100, 100))
+  #   [:indexed, :grayscale, :grayscale_alpha, :truecolor, :truecolor_alpha].each do |color_mode|
+  #     
+  #     color_mode_id = ChunkyPNG::Chunk::Header.const_get("COLOR_#{color_mode.to_s.upcase}")
+  #     filename = resource_file("gray_10x10_#{color_mode}.png")
+  #     File.open(filename, 'w') { |f| image.write(f, :color_mode => color_mode_id) }
+  #   end
+  # end
 end
 

data/spec/unit/decoding_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../spec_helper.rb', File.dirname(__FILE__))
+
+describe ChunkyPNG::PixelMatrix::Decoding do
+  include ChunkyPNG::PixelMatrix::Decoding
+  
+  describe '#decode_scanline' do
+    
+    it "should decode a line without filtering as is" do
+      bytes = [255, 255, 255, 255, 255, 255, 255, 255, 255]
+      decode_scanline(ChunkyPNG::PixelMatrix::FILTER_NONE, bytes, nil).should == bytes
+    end
+    
+    it "should decode a line with sub filtering correctly" do
+      # all white pixels
+      bytes = [255, 255, 255, 0, 0, 0, 0, 0, 0]
+      decoded_bytes = decode_scanline(ChunkyPNG::PixelMatrix::FILTER_SUB, bytes, nil)
+      decoded_bytes.should == [255, 255, 255, 255, 255, 255, 255, 255, 255]
+      
+      # all black pixels
+      bytes = [0, 0, 0, 0, 0, 0, 0, 0, 0]
+      decoded_bytes = decode_scanline(ChunkyPNG::PixelMatrix::FILTER_SUB, bytes, nil)
+      decoded_bytes.should == [0, 0, 0, 0, 0, 0, 0, 0, 0]
+      
+      # various colors
+      bytes = [255, 0, 45, 0, 255, 0, 112, 200, 178]
+      decoded_bytes = decode_scanline(ChunkyPNG::PixelMatrix::FILTER_SUB, bytes, nil)
+      decoded_bytes.should == [255, 0, 45, 255, 255, 45, 111, 199, 223]
+    end
+    
+    it "should decode a line with up filtering correctly" do
+      # previous line is all black
+      previous_bytes = [0, 0, 0, 0, 0, 0, 0, 0, 0]
+      bytes          = [255, 255, 255, 127, 127, 127, 0, 0, 0]
+      decoded_bytes  = decode_scanline(ChunkyPNG::PixelMatrix::FILTER_UP, bytes, previous_bytes)
+      decoded_bytes.should == [255, 255, 255, 127, 127, 127, 0, 0, 0]
+      
+      # previous line has various pixels
+      previous_bytes = [255, 255, 255, 127, 127, 127, 0, 0, 0]
+      bytes          = [0, 127, 255, 0, 127, 255, 0, 127, 255]
+      decoded_bytes  = decode_scanline(ChunkyPNG::PixelMatrix::FILTER_UP, bytes, previous_bytes)
+      decoded_bytes.should == [255, 126, 254, 127, 254, 126, 0, 127, 255]
+    end
+  end
+end

data/spec/unit/encoding_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../spec_helper.rb', File.dirname(__FILE__))
+
+describe ChunkyPNG::PixelMatrix::Encoding do
+  include ChunkyPNG::PixelMatrix::Encoding
+  
+  describe '#encode_scanline' do
+    
+    it "should encode a scanline without filtering correctly" do
+      bytes = [0, 0, 0, 1, 1, 1, 2, 2, 2]
+      encoded_bytes = encode_scanline(ChunkyPNG::PixelMatrix::FILTER_NONE, bytes, nil)
+      encoded_bytes.should == [0, 0, 0, 0, 1, 1, 1, 2, 2, 2]
+    end
+    
+    it "should encode a scanline with sub filtering correctly" do
+      bytes = [255, 255, 255, 255, 255, 255, 255, 255, 255]
+      encoded_bytes = encode_scanline(ChunkyPNG::PixelMatrix::FILTER_SUB, bytes, nil)
+      encoded_bytes.should == [1, 255, 255, 255, 0, 0, 0, 0, 0, 0]
+    end
+    
+    it "should encode a scanline with up filtering correctly" do
+      bytes          = [255, 255, 255, 255, 255, 255, 255, 255, 255]
+      previous_bytes = [255, 255, 255, 255, 255, 255, 255, 255, 255]
+      encoded_bytes  = encode_scanline(ChunkyPNG::PixelMatrix::FILTER_UP, bytes, previous_bytes)
+      encoded_bytes.should == [2, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    end
+  end
+end

data/spec/unit/pixel_matrix_spec.rb

@@ -2,70 +2,36 @@ require File.expand_path('../spec_helper.rb', File.dirname(__FILE__))
 
 describe ChunkyPNG::PixelMatrix do
   
-  describe '#decode_scanline' do
-    before(:each) do
-      @matrix = ChunkyPNG::PixelMatrix.new(3, 3)
-    end
-    
-    it "should decode a line without filtering as is" do
-      bytes = Array.new(@matrix.width * 3, ChunkyPNG::Color.rgb(10, 20, 30))
-      @matrix.decode_scanline(ChunkyPNG::PixelMatrix::FILTER_NONE, bytes, nil).should == bytes
-    end
+  describe '.decode' do
     
-    it "should decode a line with sub filtering correctly" do
-      # all white pixels
-      bytes = [255, 255, 255, 0, 0, 0, 0, 0, 0]
-      decoded_bytes = @matrix.decode_scanline(ChunkyPNG::PixelMatrix::FILTER_SUB, bytes, nil)
-      decoded_bytes.should == [255, 255, 255, 255, 255, 255, 255, 255, 255]
-      
-      # all black pixels
-      bytes = [0, 0, 0, 0, 0, 0, 0, 0, 0]
-      decoded_bytes = @matrix.decode_scanline(ChunkyPNG::PixelMatrix::FILTER_SUB, bytes, nil)
-      decoded_bytes.should == [0, 0, 0, 0, 0, 0, 0, 0, 0]
-      
-      # various colors
-      bytes = [255, 0, 45, 0, 255, 0, 112, 200, 178]
-      decoded_bytes = @matrix.decode_scanline(ChunkyPNG::PixelMatrix::FILTER_SUB, bytes, nil)
-      decoded_bytes.should == [255, 0, 45, 255, 255, 45, 111, 199, 223]
+    before(:each) do
+      @reference = ChunkyPNG::PixelMatrix.new(10, 10, ChunkyPNG::Pixel.rgb(100, 100, 100))
     end
     
-    it "should decode a line with up filtering correctly" do
-      # previous line is all black
-      previous_bytes = [0, 0, 0, 0, 0, 0, 0, 0, 0]
-      bytes          = [255, 255, 255, 127, 127, 127, 0, 0, 0]
-      decoded_bytes = @matrix.decode_scanline(ChunkyPNG::PixelMatrix::FILTER_UP, bytes, previous_bytes)
-      decoded_bytes.should == [255, 255, 255, 127, 127, 127, 0, 0, 0]
-      
-      # previous line has various pixels
-      previous_bytes = [255, 255, 255, 127, 127, 127, 0, 0, 0]
-      bytes          = [0, 127, 255, 0, 127, 255, 0, 127, 255]
-      decoded_bytes = @matrix.decode_scanline(ChunkyPNG::PixelMatrix::FILTER_UP, bytes, previous_bytes)
-      decoded_bytes.should == [255, 126, 254, 127, 254, 126, 0, 127, 255]
+    [:indexed, :grayscale, :grayscale_alpha, :truecolor, :truecolor_alpha].each do |color_mode|
+      it "should decode an image with color mode #{color_mode} correctly" do
+        ds = ChunkyPNG.load(resource_file("gray_10x10_#{color_mode}.png"))
+        ds.pixel_matrix.should == @reference
+      end
     end
   end
   
-  describe '#encode_scanline' do
+  describe '.encode' do
     before(:each) do
-      @matrix = ChunkyPNG::PixelMatrix.new(3, 3)
-    end
-    
-    it "should encode a scanline without filtering correctly" do
-      bytes = [0, 0, 0, 1, 1, 1, 2, 2, 2]
-      encoded_bytes = @matrix.encode_scanline(ChunkyPNG::PixelMatrix::FILTER_NONE, bytes, nil, nil)
-      encoded_bytes.should == [0, 0, 0, 0, 1, 1, 1, 2, 2, 2]
+      @reference = ChunkyPNG::PixelMatrix.new(10, 10, ChunkyPNG::Pixel.rgb(100, 100, 100))
     end
     
-    it "should encode a scanline with sub filtering correctly" do
-      bytes = [255, 255, 255, 255, 255, 255, 255, 255, 255]
-      encoded_bytes = @matrix.encode_scanline(ChunkyPNG::PixelMatrix::FILTER_SUB, bytes, nil, nil)
-      encoded_bytes.should == [1, 255, 255, 255, 0, 0, 0, 0, 0, 0]
+    [:indexed, :grayscale, :grayscale_alpha, :truecolor, :truecolor_alpha].each do |color_mode|
+      it "should encode an image with color mode #{color_mode} correctly" do
+
+        filename = resource_file("_tmp_#{color_mode}.png")
+        File.open(filename, 'w') { |f| @reference.to_datastream.write(f) }
+        
+        ChunkyPNG.load(filename).pixel_matrix.should == @reference
+        
+        File.unlink(filename)
+      end
     end
     
-    it "should encode a scanline with up filtering correctly" do
-      bytes          = [255, 255, 255, 255, 255, 255, 255, 255, 255]
-      previous_bytes = [255, 255, 255, 255, 255, 255, 255, 255, 255]
-      encoded_bytes = @matrix.encode_scanline(ChunkyPNG::PixelMatrix::FILTER_UP, bytes, previous_bytes, nil)
-      encoded_bytes.should == [2, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-    end    
   end
 end

data/spec/unit/pixel_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../spec_helper.rb', File.dirname(__FILE__))
+
+describe ChunkyPNG::Pixel do
+
+  before(:each) do
+    @white             = ChunkyPNG::Pixel.rgba(255, 255, 255, 255)
+    @black             = ChunkyPNG::Pixel.rgba(  0,   0,   0, 255)
+    @opaque            = ChunkyPNG::Pixel.rgba( 10, 100, 150, 255)
+    @non_opaque        = ChunkyPNG::Pixel.rgba( 10, 100, 150, 100)
+    @fully_transparent = ChunkyPNG::Pixel.rgba( 10, 100, 150,   0)
+  end
+
+  it "should represent pixels as the correct number" do
+    @white.value.should  == 0xffffffff
+    @black.value.should  == 0x000000ff
+    @opaque.value.should == 0x0a6496ff
+  end
+
+  it "should correctly check for opaqueness" do
+    @white.should be_opaque
+    @black.should be_opaque
+    @opaque.should be_opaque
+    @non_opaque.should_not be_opaque
+    @fully_transparent.should_not be_opaque
+  end
+  
+  it "should convert the individual color values back correctly" do
+    @opaque.to_truecolor_bytes.should == [10, 100, 150]
+    @non_opaque.to_truecolor_alpha_bytes.should == [10, 100, 150, 100]
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: chunky_png
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-10 00:00:00 +01:00
+date: 2010-01-12 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -33,19 +33,30 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - spec/spec_helper.rb
+- spec/resources/gray_10x10_grayscale.png
+- spec/resources/gray_10x10.png
 - .gitignore
+- spec/resources/gray_10x10_truecolor_alpha.png
 - lib/chunky_png/pixel_matrix.rb
 - LICENSE
+- spec/resources/gray_10x10_truecolor.png
+- lib/chunky_png/pixel_matrix/decoding.rb
 - lib/chunky_png/chunk.rb
+- spec/unit/encoding_spec.rb
 - Rakefile
 - README.rdoc
-- spec/resources/indexed_10x10.png
+- spec/resources/gray_10x10_indexed.png
 - spec/integration/image_spec.rb
+- lib/chunky_png/pixel.rb
 - lib/chunky_png/palette.rb
 - lib/chunky_png/datastream.rb
 - chunky_png.gemspec
 - tasks/github-gem.rake
+- spec/unit/decoding_spec.rb
+- spec/resources/gray_10x10_grayscale_alpha.png
+- lib/chunky_png/pixel_matrix/encoding.rb
 - lib/chunky_png/image.rb
+- spec/unit/pixel_spec.rb
 - spec/unit/pixel_matrix_spec.rb
 - lib/chunky_png.rb
 has_rdoc: true
@@ -82,5 +93,8 @@ signing_key:
 specification_version: 3
 summary: Pure ruby library for read/write, chunk-level access to PNG files
 test_files: 
+- spec/unit/encoding_spec.rb
 - spec/integration/image_spec.rb
+- spec/unit/decoding_spec.rb
+- spec/unit/pixel_spec.rb
 - spec/unit/pixel_matrix_spec.rb