chunky_png 0.0.5 → 0.5.0

data/lib/chunky_png/image.rb

@@ -1,43 +1,44 @@
 module ChunkyPNG
-  class Image
-    
-    attr_reader :pixel_matrix
-    
-    def initialize(width, height, background_color = ChunkyPNG::Pixel::TRANSPARENT)
-      @pixel_matrix = ChunkyPNG::PixelMatrix.new(width, height, background_color)
-    end
-    
-    def self.from_pixel_matrix(matrix)
-      self.new(matrix.width, matrix.height, matrix.pixels)
-    end
+
+  # Image class
+  #
+  class Image < Canvas
+
+    METADATA_COMPRESSION_TRESHOLD = 300
     
-    def width
-      pixel_matrix.width
-    end
+    attr_accessor :metadata
     
-    def height
-      pixel_matrix.height
+    def initialize(width, height, initial = ChunkyPNG::Color::TRANSPARENT, metadata = {})
+      super(width, height, initial)
+      @metadata = metadata
+      @metadata_compression_treshhold = 300
     end
     
-    def [](x, y)
-      pixel_matrix[x,y]
-    end
-
-    def []=(x, y, pixel)
-      pixel_matrix[x,y] = pixel
+    def initialize_copy(other)
+      super(other)
+      @metdata = other.metadata
     end
     
-    def pixels
-      pixel_matrix.pixels
+    def metadata_chunks
+      metadata.map do |key, value|
+        if value.length >= METADATA_COMPRESSION_TRESHOLD
+          ChunkyPNG::Chunk::CompressedText.new(key, value)
+        else
+          ChunkyPNG::Chunk::Text.new(key, value)
+        end
+      end
     end
     
-    def write(io, constraints = {})
-      datastream = pixel_matrix.to_datastream(constraints)
-      datastream.write(io)
+    def to_datastream(constraints = {})
+      ds = super(constraints)
+      ds.other_chunks += metadata_chunks
+      return ds
     end
     
-    def save(filename, constraints = {})
-      File.open(filename, 'w') { |io| write(io, constraints) }
+    def self.from_datastream(ds)
+      image = super(ds)
+      image.metadata = ds.metadata
+      return image
     end
   end
-end
+end

data/lib/chunky_png/palette.rb

@@ -2,90 +2,92 @@ module ChunkyPNG
 
   # A palette describes the set of colors that is being used for an image.
   #
-  # A PNG image can contain an explicit palette which defines the colors of that image,
-  # but can also use an implicit palette, e.g. all truecolor colors or all grayscale colors.
+  # A PNG image can contain an explicit palette which defines the colors of
+  # that image, but can also use an implicit palette, e.g. all truecolor
+  # colors or all grayscale colors.
   #
-  # This palette supports decoding colors from a palette if an explicit palette is provided 
-  # in a PNG datastream, and it supports encoding colors to an explicit matrix.
+  # This palette supports decoding colors from a palette if an explicit
+  # palette is provided in a PNG datastream, and it supports encoding colors
+  # to an explicit palette (stores as PLTE & tRNS chunks in a PNG file).
   #
-  # @see ChunkyPNG::Pixel
+  # @see ChunkyPNG::Color
   class Palette < SortedSet
-    
+
     # Builds a new palette given a set (Enumerable instance) of colors.
     #
-    # @param [Enumerbale<ChunkyPNG::Pixel>] enum The set of colors to include in this palette.
+    # @param [Enumerbale<CFixnum>] enum The set of colors to include in this palette.
     #   This Enumerbale can contains duplicates.
-    # @param [Array] decoding_map An array of colors in the exact order at which 
+    # @param [Array] decoding_map An array of colors in the exact order at which
     #   they appeared in the palette chunk, so that this array can be used for decoding.
     def initialize(enum, decoding_map = nil)
       super(enum)
       @decoding_map = decoding_map if decoding_map
     end
-    
-    # Builds a palette instance from a PLTE chunk and optionally a tRNS chunk 
+
+    # Builds a palette instance from a PLTE chunk and optionally a tRNS chunk
     # from a PNG datastream.
     #
     # This method will cerate a palette that is suitable for decoding an image.
     #
     # @param [ChunkyPNG::Chunk::Palette] The palette chunk to load from
     # @param [ChunkyPNG::Chunk::Transparency, nil] The optional transparency chunk.
-    # @return [ChunkyPNG::Palette] The loaded palette instance. 
+    # @return [ChunkyPNG::Palette] The loaded palette instance.
     # @see ChunkyPNG::Palette#can_decode?
     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)
+        alpha_channel = Array.new(palatte_bytes.size / 3, ChunkyPNG::Color::MAX)
       end
-      
+
       index = 0
       palatte_bytes.each_slice(3) do |bytes|
         bytes << alpha_channel[index]
-        decoding_map << ChunkyPNG::Pixel.rgba(*bytes)
+        decoding_map << ChunkyPNG::Color.rgba(*bytes)
         index += 1
       end
-      
+
       self.new(decoding_map, decoding_map)
     end
-    
-    # Builds a palette instance from a given pixel matrix.
-    # @param [ChunkyPNG::PixelMatrix] pixel_matrix The pixel matrix to create a palette for.
+
+    # Builds a palette instance from a given canvas.
+    # @param [ChunkyPNG::Canvas] canvas The canvas to create a palette for.
     # @return [ChunkyPNG::Palette] The palette instance.
-    def self.from_pixel_matrix(pixel_matrix)
-      self.new(pixel_matrix.pixels.map { |fn| ChunkyPNG::Pixel.new(fn) })
+    def self.from_canvas(canvas)
+      self.new(canvas.pixels)
     end
-    
+
     # Builds a palette instance from a given set of pixels.
-    # @param [Enumerable<ChunkyPNG::Pixel>] pixels An enumeration of pixels to create a palette for
+    # @param [Enumerable<Fixnum>] pixels An enumeration of pixels to create a palette for
     # @return [ChunkyPNG::Palette] The palette instance.
     def self.from_pixels(pixels)
       self.new(pixels)
     end
-    
+
     # Checks whether the size of this palette is suitable for indexed storage.
     # @return [true, false] True if the number of colors in this palette is less than 256.
     def indexable?
       size < 256
     end
-    
+
     # Check whether this pelette only contains opaque colors.
     # @return [true, false] True if all colors in this palette are opaque.
-    # @see ChunkyPNG::Pixel#opaque?
+    # @see ChunkyPNG::Color#opaque?
     def opaque?
-      all? { |pixel| pixel.opaque? }
+      all? { |color| Color.opaque?(color) }
     end
-    
+
     # Check whether this pelette only contains grayscale colors.
     # @return [true, false] True if all colors in this palette are grayscale teints.
-    # @see ChunkyPNG::Pixel#grayscale??
+    # @see ChunkyPNG::Color#grayscale??
     def grayscale?
-      all? { |pixel| pixel.grayscale? }
+      all? { |color| Color.grayscale?(color) }
     end
 
     # Checks whether this palette is suitable for decoding an image from a datastream.
@@ -97,7 +99,7 @@ module ChunkyPNG
     def can_decode?
       !@decoding_map.nil?
     end
-    
+
     # Checks whether this palette is suitable for encoding an image from to datastream.
     #
     # This requires that the position of the color in the future palette chunk is known,
@@ -107,38 +109,38 @@ module ChunkyPNG
     def can_encode?
       !@encoding_map.nil?
     end
-    
+
     # Returns a color, given the position in the original palette chunk.
     # @param [Fixnum] index The 0-based position of the color in the palette.
-    # @return [ChunkyPNG::Pixel] The color that is stored in the palette under the given index
+    # @return [ChunkyPNG::Color] The color that is stored in the palette under the given index
     # @see ChunkyPNG::Palette#can_decode?
     def [](index)
       @decoding_map[index]
     end
-    
+
     # Returns the position of a color in the palette
-    # @param [ChunkyPNG::Pixel] color The color for which to look up the index.
+    # @param [ChunkyPNG::Color] color The color for which to look up the index.
     # @return [Fixnum] The 0-based position of the color in the palette.
     # @see ChunkyPNG::Palette#can_encode?
     def index(color)
-      @encoding_map[ChunkyPNG::Pixel.new(color)]
+      @encoding_map[color]
     end
-    
+
     # Creates a tRNS chunk that corresponds with this palette to store the
     # alpha channel of all colors.
     #
-    # Note that this chunk can be left out of every color in the palette is 
+    # Note that this chunk can be left out of every color in the palette is
     # opaque, and the image is encoded using indexed colors.
     #
     # @return [ChunkyPNG::Chunk::Transparency] The tRNS chunk.
     def to_trns_chunk
-      ChunkyPNG::Chunk::Transparency.new('tRNS', map(&:a).pack('C*'))
+      ChunkyPNG::Chunk::Transparency.new('tRNS', map { |c| ChunkyPNG::Color.a(c) }.pack('C*'))
     end
-    
+
     # Creates a PLTE chunk that corresponds with this palette to store the
     # r, g and b channels of all colors.
     #
-    # Note that a PLTE chunk should only be included if the image is 
+    # Note that a PLTE chunk should only be included if the image is
     # encoded using index colors. After this chunk has been built, the
     # palette becomes suitable for encoding an image.
     #
@@ -146,16 +148,16 @@ module ChunkyPNG
     # @see ChunkyPNG::Palette#can_encode?
     def to_plte_chunk
       @encoding_map = {}
-      colors     = []
-      
+      colors        = []
+
       each_with_index do |color, index|
         @encoding_map[color] = index
-        colors += color.to_truecolor_bytes
+        colors += ChunkyPNG::Color.to_truecolor_bytes(color)
       end
-      
+
       ChunkyPNG::Chunk::Palette.new('PLTE', colors.pack('C*'))
     end
-    
+
     # Determines the most suitable colormode for this palette.
     # @return [Fixnum] The colormode which would create the smalles possible
     #    file for images that use this exact palette.

data/lib/chunky_png/rmagick.rb

@@ -0,0 +1,43 @@
+require 'rmagick'
+
+module ChunkyPNG
+  
+  # Methods for importing and exporting RMagick image objects.
+  #
+  # By default, this module is disabled because of the dependency on RMagick.
+  # You need to include this module yourself if you want to use it. 
+  #
+  # @example
+  #
+  #    require 'rmagick
+  #    require 'chunky_png/rmagick'
+  #    
+  #    canvas = ChunkyPNG::Canvas.from_file('filename.png')
+  #    image = ChunkyPNG::RMagick.export(canvas)
+  #    
+  #    # do something with the image using RMagick
+  #    
+  #    updated_canvas = ChunkyPNG::RMagick.import(image)
+  #
+  module RMagick
+    
+    extend self
+    
+    # Imports an RMagick image as Canvas object.
+    # @param [Magick::Image] image The image to import
+    # @return [ChunkyPNG::Canvas] The canvas, constructed from the RMagick image.
+    def import(image)
+      pixels = image.export_pixels_to_str(0, 0, image.columns, image.rows, 'RGBA')
+      ChunkyPNG::Canvas.from_rgba_stream(image.columns, image.rows, pixels)
+    end
+
+    # Exports a Canvas as RMagick image instance.
+    # @param [ChunkyPNG::Canvas] canvas The canvas to export.
+    # @return [Magick::Image] The RMagick image constructed from the Canvas instance.
+    def export(canvas)
+      image = Magick::Image.new(canvas.width, canvas.height)
+      image.import_pixels(0,0, canvas.width, canvas.height, 'RGBA', canvas.pixels.pack('N*'))
+      image
+    end
+  end
+end

data/spec/chunky_png/canvas/adam7_interlacing_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Canvas::Adam7Interlacing do
+  include ChunkyPNG::Canvas::Adam7Interlacing
+
+  describe '#adam7_pass_sizes' do
+    it "should get the pass sizes for a 8x8 image correctly" do
+      adam7_pass_sizes(8, 8).should == [
+          [1, 1], [1, 1], [2, 1], [2, 2], [4, 2], [4, 4], [8, 4]
+        ]
+    end
+
+    it "should get the pass sizes for a 12x12 image correctly" do
+      adam7_pass_sizes(12, 12).should == [
+          [2, 2], [1, 2], [3, 1], [3, 3], [6, 3], [6, 6], [12, 6]
+        ]
+    end
+
+    it "should get the pass sizes for a 33x47 image correctly" do
+      adam7_pass_sizes(33, 47).should == [
+          [5, 6], [4, 6], [9, 6], [8, 12], [17, 12], [16, 24], [33, 23]
+        ]
+    end
+
+    it "should get the pass sizes for a 1x1 image correctly" do
+      adam7_pass_sizes(1, 1).should == [
+          [1, 1], [0, 1], [1, 0], [0, 1], [1, 0], [0, 1], [1, 0]
+        ]
+    end
+
+    it "should get the pass sizes for a 0x0 image correctly" do
+      adam7_pass_sizes(0, 0).should == [
+          [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]
+        ]
+    end
+
+    it "should always maintain the same amount of pixels in total" do
+      [[8, 8], [12, 12], [33, 47], [1, 1], [0, 0]].each do |(width, height)|
+        pass_sizes = adam7_pass_sizes(width, height)
+        pass_sizes.inject(0) { |sum, (w, h)| sum + (w*h) }.should == width * height
+      end
+    end
+  end
+
+  describe '#adam7_multiplier_offset' do
+    it "should get the multiplier and offset values for pass 1 correctly" do
+      adam7_multiplier_offset(0).should == { :x_offset => 0, :y_multiplier => 8, :y_offset => 0, :x_multiplier => 8 }
+    end
+    
+    it "should get the multiplier and offset values for pass 2 correctly" do
+      adam7_multiplier_offset(1).should == { :x_offset => 4, :y_multiplier => 8, :y_offset => 0, :x_multiplier => 8 }
+    end
+    
+    it "should get the multiplier and offset values for pass 3 correctly" do
+      adam7_multiplier_offset(2).should == { :x_offset => 0, :y_multiplier => 8, :y_offset => 4, :x_multiplier => 4 }
+    end
+    
+    it "should get the multiplier and offset values for pass 4 correctly" do
+      adam7_multiplier_offset(3).should == { :x_offset => 2, :y_multiplier => 4, :y_offset => 0, :x_multiplier => 4 }
+    end
+    
+    it "should get the multiplier and offset values for pass 5 correctly" do
+      adam7_multiplier_offset(4).should == { :x_offset => 0, :y_multiplier => 4, :y_offset => 2, :x_multiplier => 2 }
+    end
+
+    it "should get the multiplier and offset values for pass 6 correctly" do
+      adam7_multiplier_offset(5).should == { :x_offset => 1, :y_multiplier => 2, :y_offset => 0, :x_multiplier => 2 }
+    end
+    
+    it "should get the multiplier and offset values for pass 7 correctly" do
+      adam7_multiplier_offset(6).should == { :x_offset => 0, :y_multiplier => 2, :y_offset => 1, :x_multiplier => 1 }
+    end
+  end
+
+  describe '#adam7_merge_pass' do
+    before(:each) { @reference = reference_canvas('adam7') } 
+    
+    it "should merge the submatrices correctly" do
+      submatrices = [
+        ChunkyPNG::Canvas.new(1, 1,  168430335), # r = 10
+        ChunkyPNG::Canvas.new(1, 1,  336860415), # r = 20
+        ChunkyPNG::Canvas.new(2, 1,  505290495), # r = 30
+        ChunkyPNG::Canvas.new(2, 2,  677668095), # r = 40
+        ChunkyPNG::Canvas.new(4, 2,  838912255), # r = 50
+        ChunkyPNG::Canvas.new(4, 4, 1023344895), # r = 60
+        ChunkyPNG::Canvas.new(8, 4, 1175063295), # r = 70
+      ]
+      
+      canvas = ChunkyPNG::Canvas.new(8,8)
+      submatrices.each_with_index { |m, pass| adam7_merge_pass(pass, canvas, m) }
+      canvas.should == @reference
+    end
+  end
+
+  describe '#adam7_extract_pass' do
+    before(:each) { @canvas = reference_canvas('adam7') }
+
+    1.upto(7) do |pass|
+      it "should extract pass #{pass} correctly" do
+        sm = adam7_extract_pass(pass - 1, @canvas)
+        sm.pixels.length.should == sm.width * sm.height
+        sm.pixels.uniq.length.should == 1
+        (ChunkyPNG::Color.r(sm[0,0]) / 10).should == pass
+      end
+    end
+  end
+
+end

data/spec/chunky_png/canvas/png_decoding_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Canvas::PNGDecoding do
+  include ChunkyPNG::Canvas::PNGDecoding
+
+  describe '#decode_png_scanline' do
+
+    it "should decode a line without filtering as is" do
+      bytes = [255, 255, 255, 255, 255, 255, 255, 255, 255]
+      decode_png_scanline(ChunkyPNG::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_png_scanline(ChunkyPNG::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_png_scanline(ChunkyPNG::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_png_scanline(ChunkyPNG::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_png_scanline(ChunkyPNG::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_png_scanline(ChunkyPNG::FILTER_UP, bytes, previous_bytes)
+      decoded_bytes.should == [255, 126, 254, 127, 254, 126, 0, 127, 255]
+    end
+    
+    it "should decode a line with average filtering correctly" do
+      previous = [10, 20, 30, 40, 50, 60, 70, 80, 80, 100, 110, 120]
+      current  = [ 0,  0, 10, 20, 10,  0,  0, 40, 10,  20, 190,   0]
+      decoded  = decode_png_scanline(ChunkyPNG::FILTER_AVERAGE, current, previous)
+      decoded.should == [5, 10, 25, 45, 45, 55, 80, 125, 105, 150, 114, 165]
+    end
+
+    it "should decode a line with paeth filtering correctly" do
+      previous = [10, 20, 30, 40, 50, 60, 70, 80, 80, 100, 110, 120]
+      current  = [ 0,  0, 10, 20, 10,  0,  0, 40, 10,  20, 190,   0]
+      decoded  = decode_png_scanline(ChunkyPNG::FILTER_PAETH, current, previous)
+      decoded.should == [10, 20, 40, 60, 60, 60, 70, 120, 90, 120, 54, 120]
+    end
+  end
+
+  describe '.from_datastream' do
+
+    [:indexed, :grayscale, :grayscale_alpha, :truecolor, :truecolor_alpha].each do |color_mode|
+      it "should decode an image with color mode #{color_mode} correctly" do
+        reference = ChunkyPNG::Canvas.new(10, 10, ChunkyPNG::Color.rgb(100, 100, 100))
+        canvas = ChunkyPNG::Canvas.from_file(resource_file("gray_10x10_#{color_mode}.png"))
+        canvas.should == reference
+      end
+    end
+
+    it "should decode a transparent image correctly" do
+      reference = ChunkyPNG::Canvas.new(10, 10, ChunkyPNG::Color.rgba(100, 100, 100, 128))
+      canvas    = ChunkyPNG::Canvas.from_file(resource_file("transparent_gray_10x10.png"))
+      canvas.should == reference
+    end
+
+    it "should decode an interlaced image correctly" do
+      canvas_i  = ChunkyPNG::Canvas.from_file(resource_file("16x16_interlaced.png"))
+      canvas_ni = ChunkyPNG::Canvas.from_file(resource_file("16x16_non_interlaced.png"))
+      canvas_i.should == canvas_ni
+    end
+  end
+end