chunky_png 0.0.5 → 0.5.0

data/lib/chunky_png/pixel_matrix/decoding.rb

@@ -1,159 +0,0 @@
-module ChunkyPNG
-  class PixelMatrix
-    module Decoding
-      
-      def decode(ds)
-        raise "Only 8-bit color depth is currently supported by ChunkyPNG!" unless ds.header_chunk.depth == 8
-        
-        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
-        interlace  = ds.header_chunk.interlace
-        palette    = ChunkyPNG::Palette.from_chunks(ds.palette_chunk, ds.transparency_chunk)
-        decode_pixelstream(stream, width, height, color_mode, palette, interlace)
-      end
-      
-      def decode_pixelstream(stream, width, height, color_mode = ChunkyPNG::COLOR_TRUECOLOR, palette = nil, interlace = ChunkyPNG::INTERLACING_NONE)
-        raise "This palette is not suitable for decoding!" if palette && !palette.can_decode?
-        
-        pixel_size    = Pixel.bytesize(color_mode)
-        pixel_decoder = case color_mode
-          when ChunkyPNG::COLOR_TRUECOLOR       then lambda { |bytes| ChunkyPNG::Pixel.rgb(*bytes) }
-          when ChunkyPNG::COLOR_TRUECOLOR_ALPHA then lambda { |bytes| ChunkyPNG::Pixel.rgba(*bytes) }
-          when ChunkyPNG::COLOR_INDEXED         then lambda { |bytes| palette[bytes.first] }
-          when ChunkyPNG::COLOR_GRAYSCALE       then lambda { |bytes| ChunkyPNG::Pixel.grayscale(*bytes) }
-          when ChunkyPNG::COLOR_GRAYSCALE_ALPHA then lambda { |bytes| ChunkyPNG::Pixel.grayscale(*bytes) }
-          else raise "No suitable pixel decoder found for color mode #{color_mode}!"
-        end
-        
-        pixels = case interlace
-          when ChunkyPNG::INTERLACING_NONE  then decode_interlacing_none(stream, width, height, pixel_size, pixel_decoder)
-          when ChunkyPNG::INTERLACING_ADAM7 then decode_interlacing_adam7(stream, width, height, pixel_size, pixel_decoder)
-          else raise "Don't know how the handle interlacing method #{interlace}!"
-        end
-
-        return ChunkyPNG::PixelMatrix.new(width, height, pixels)
-      end
-      
-      protected
-      
-      def decode_image_pass(stream, width, height, pixel_size, pixel_decoder, start_pos = 0)
-        pixels = []
-        decoded_bytes = Array.new(width * pixel_size, 0)
-        height.times do |line_no|
-          
-          if width > 0
-            
-            # get bytes of scanline
-            position       = start_pos + 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
-        end
-        pixels
-      end
-      
-      def decode_interlacing_none(stream, width, height, pixel_size, pixel_decoder)
-        raise "Invalid stream length!" unless stream.length == width * height * pixel_size + height
-        decode_image_pass(stream, width, height, pixel_size, pixel_decoder)
-      end
-      
-      def decode_interlacing_adam7(stream, width, height, pixel_size, pixel_decoder)
-        start_pos = 0
-        sub_matrices = adam7_pass_sizes(width, height).map do |(pass_width, pass_height)|
-          pixels = decode_image_pass(stream, pass_width, pass_height, pixel_size, pixel_decoder, start_pos)
-          start_pos += (pass_width * pass_height * pixel_size) + pass_height
-          [pass_width, pass_height, pixels]
-        end
-
-        pixels = Array.new(width * height, ChunkyPNG::Pixel::TRANSPARENT)
-        0.upto(6) { |pass| adam7_merge_pass(pass, width, height, pixels, *sub_matrices[pass]) }
-        pixels
-      end
-
-      def adam7_multiplier_offset(pass)
-        {
-          :x_multiplier => 8 >> (pass >> 1),
-          :x_offset     => (pass & 1 == 0) ? 0 : 8 >> ((pass + 1) >> 1),
-          :y_multiplier => pass == 0 ? 8 : 8 >> ((pass - 1) >> 1),
-          :y_offset     => (pass == 0 || pass & 1 == 1) ? 0 : 8 >> (pass >> 1)
-        }
-      end
-      
-      def adam7_merge_pass(pass, width, height, pixels, sm_width, sm_height, sm_pixels)
-        m_o = adam7_multiplier_offset(pass)
-        0.upto(sm_height - 1) do |y|
-          0.upto(sm_width - 1) do |x|
-            new_x = x * m_o[:x_multiplier] + m_o[:x_offset]
-            new_y = y * m_o[:y_multiplier] + m_o[:y_offset]
-            pixels[width * new_y + new_x] = sm_pixels[sm_width * y + x]
-          end
-        end
-        pixels
-      end
-      
-      def adam7_pass_sizes(width, height)
-        (0...7).map do |pass|
-          m_o = adam7_multiplier_offset(pass)
-          [ ((width  - m_o[:x_offset] ) / m_o[:x_multiplier].to_f).ceil,
-            ((height - m_o[:y_offset] ) / m_o[:y_multiplier].to_f).ceil,]
-        end
-      end
-
-      def decode_scanline(filter, bytes, previous_bytes, pixelsize = 3)
-        case filter
-        when ChunkyPNG::FILTER_NONE    then decode_scanline_none(    bytes, previous_bytes, pixelsize)
-        when ChunkyPNG::FILTER_SUB     then decode_scanline_sub(     bytes, previous_bytes, pixelsize)
-        when ChunkyPNG::FILTER_UP      then decode_scanline_up(      bytes, previous_bytes, pixelsize)
-        when ChunkyPNG::FILTER_AVERAGE then decode_scanline_average( bytes, previous_bytes, pixelsize)
-        when ChunkyPNG::FILTER_PAETH   then decode_scanline_paeth(   bytes, previous_bytes, pixelsize)
-        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
-
-      def decode_scanline_average(bytes, previous_bytes, pixelsize = 3)
-        bytes.each_with_index do |byte, i|
-          a = (i >= pixelsize) ? bytes[i - pixelsize] : 0
-          b = previous_bytes[i]
-          bytes[i] = (byte + (a + b / 2).floor) % 256
-        end
-        bytes
-      end
-
-      def decode_scanline_paeth(bytes, previous_bytes, pixelsize = 3)
-        bytes.each_with_index do |byte, i|
-          a = (i >= pixelsize) ? bytes[i - pixelsize] : 0
-          b = previous_bytes[i]
-          c = (i >= pixelsize) ? previous_bytes[i - pixelsize] : 0
-          p = a + b - c
-          pa = (p - a).abs
-          pb = (p - b).abs
-          pc = (p - c).abs
-          pr = (pa <= pb && pa <= pc) ? a : (pb <= pc ? b : c)
-          bytes[i] = (byte + pr) % 256
-        end
-        bytes
-      end
-    end
-  end
-end

data/lib/chunky_png/pixel_matrix/encoding.rb

@@ -1,89 +0,0 @@
-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::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::COLOR_TRUECOLOR, palette = nil)
-
-        pixel_encoder = case color_mode
-          when ChunkyPNG::COLOR_TRUECOLOR       then lambda { |pixel| pixel.to_truecolor_bytes }
-          when ChunkyPNG::COLOR_TRUECOLOR_ALPHA then lambda { |pixel| pixel.to_truecolor_alpha_bytes }
-          when ChunkyPNG::COLOR_INDEXED         then lambda { |pixel| pixel.to_indexed_bytes(palette) }
-          when ChunkyPNG::COLOR_GRAYSCALE       then lambda { |pixel| pixel.to_grayscale_bytes }
-          when ChunkyPNG::COLOR_GRAYSCALE_ALPHA then lambda { |pixel| pixel.to_grayscale_alpha_bytes }
-          else raise "Cannot encode pixels for this mode: #{color_mode}!"
-        end
-        
-        if color_mode == ChunkyPNG::COLOR_INDEXED && !palette.can_encode?
-          raise "This palette is not suitable for encoding!"
-        end
-
-        pixel_size = Pixel.bytesize(color_mode)
-
-        stream   = ""
-        previous_bytes = Array.new(pixel_size * width, 0)
-        each_scanline do |line|
-          unencoded_bytes = line.map(&pixel_encoder).flatten
-          stream << encode_scanline_up(unencoded_bytes, previous_bytes, pixel_size).pack('C*')
-          previous_bytes  = unencoded_bytes
-        end
-        return stream
-      end
-
-      def encode_scanline(filter, bytes, previous_bytes = nil, pixelsize = 3)
-        case filter
-        when ChunkyPNG::FILTER_NONE    then encode_scanline_none( bytes, previous_bytes, pixelsize)
-        when ChunkyPNG::FILTER_SUB     then encode_scanline_sub(  bytes, previous_bytes, pixelsize)
-        when ChunkyPNG::FILTER_UP      then encode_scanline_up(   bytes, previous_bytes, pixelsize)
-        when ChunkyPNG::FILTER_AVERAGE then raise "Average filter are not yet supported!"
-        when ChunkyPNG::FILTER_PAETH   then raise "Paeth filter are not yet supported!"
-        else raise "Unknown filter type"
-        end
-      end
-
-      def encode_scanline_none(original_bytes, previous_bytes = nil, pixelsize = 3)
-        [ChunkyPNG::FILTER_NONE] + original_bytes
-      end
-
-      def encode_scanline_sub(original_bytes, previous_bytes = nil, pixelsize = 3)
-        encoded_bytes = []
-        original_bytes.length.times do |index|
-          a = (index >= pixelsize) ? original_bytes[index - pixelsize] : 0
-          encoded_bytes[index] = (original_bytes[index] - a) % 256
-        end
-        [ChunkyPNG::FILTER_SUB] + encoded_bytes
-      end
-
-      def encode_scanline_up(original_bytes, previous_bytes, pixelsize = 3)
-        encoded_bytes = []
-        original_bytes.length.times do |index|
-          b = previous_bytes[index]
-          encoded_bytes[index] = (original_bytes[index] - b) % 256
-        end
-        [ChunkyPNG::FILTER_UP] + encoded_bytes
-      end
-    end
-  end
-end

data/spec/unit/decoding_spec.rb

@@ -1,83 +0,0 @@
-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::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::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::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::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::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::FILTER_UP, bytes, previous_bytes)
-      decoded_bytes.should == [255, 126, 254, 127, 254, 126, 0, 127, 255]
-    end
-  end
-  
-  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
-end

data/spec/unit/encoding_spec.rb

@@ -1,27 +0,0 @@
-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::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::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::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

@@ -1,93 +0,0 @@
-require File.expand_path('../spec_helper.rb', File.dirname(__FILE__))
-
-describe ChunkyPNG::PixelMatrix do
-  
-  describe '.from_rgb_stream' do
-    it "should load an image correctly from a datastrean" do
-      reference = ChunkyPNG.load(resource_file('pixelstream_reference.png')).pixel_matrix
-      
-      File.open(resource_file('pixelstream.rgb')) do |stream|
-        pm = ChunkyPNG::PixelMatrix.from_rgb_stream(240, 180, stream)
-        pm.should == reference
-      end
-    end
-  end
-  
-  describe '.decode' 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::PixelMatrix.new(10, 10, ChunkyPNG::Pixel.rgb(100, 100, 100))
-        ds = ChunkyPNG.load(resource_file("gray_10x10_#{color_mode}.png"))
-        ds.pixel_matrix.should == reference
-      end
-    end
-    
-    it "should decode a transparent image correctly" do
-      reference = ChunkyPNG::PixelMatrix.new(10, 10, ChunkyPNG::Pixel.rgba(100, 100, 100, 128))
-      ds = ChunkyPNG.load(resource_file("transparent_gray_10x10.png"))
-      ds.pixel_matrix.should == reference
-    end
-    
-    it "should decode an interlaced image correctly" do
-      ds_i  = ChunkyPNG.load(resource_file("16x16_interlaced.png"))
-      ds_ni = ChunkyPNG.load(resource_file("16x16_non_interlaced.png"))
-      ds_i.pixel_matrix.should == ds_ni.pixel_matrix
-    end
-  end
-  
-  describe '.encode' do
-    before(:each) do
-      @reference = ChunkyPNG::PixelMatrix.new(10, 10, ChunkyPNG::Pixel.rgb(100, 100, 100))
-    end
-    
-    [: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
-  end
-  
-  describe '#crop' do
-    before(:each) do
-      @matrix = ChunkyPNG.load(resource_file('operations.png')).pixel_matrix
-    end
-    
-    it "should crop the right pixels from the original matrix" do
-      cropped = @matrix.crop(10, 5, 2, 3)
-      cropped.size.should == [2, 3]
-      cropped[0, 0].r.should == 10 * 16
-      cropped[0, 0].g.should ==  5 * 16
-    end
-  end
-  
-  describe '#compose' do
-    before(:each) do
-      @matrix = ChunkyPNG.load(resource_file('operations.png')).pixel_matrix
-    end
-    
-    it "should compose pixels correctly" do
-      submatrix = ChunkyPNG::PixelMatrix.new(4, 8, ChunkyPNG::Pixel.rgba(0, 0, 0, 75))
-      @matrix.compose(submatrix, 8, 4)
-      # display(@matrix)
-    end
-  end
-  
-  describe '#replace' do
-    before(:each) do
-      @matrix = ChunkyPNG.load(resource_file('operations.png')).pixel_matrix
-    end
-    
-    it "should replace the correct pixels" do
-      submatrix = ChunkyPNG::PixelMatrix.new(3, 2, ChunkyPNG::Pixel.rgb(255, 255, 0))
-      @matrix.replace(submatrix, 5, 4)
-      # display(@matrix)
-    end
-  end
-end