zpng 0.2.0 → 0.2.1

data/lib/zpng/metadata.rb

@@ -0,0 +1,20 @@
+module ZPNG
+  class Metadata < Array
+    def initialize img = nil
+      return unless img
+      img.chunks.each do |c|
+        next unless c.is_a?(TextChunk)
+        self << [c.keyword, c.text, c.to_hash]
+      end
+    end
+
+    def [] *args
+      if args.first.is_a?(String)
+        each{ |a| return a[1] if a[0] == args.first }
+        nil
+      else
+        super
+      end
+    end
+  end
+end

data/lib/zpng/pixels.rb

@@ -0,0 +1,25 @@
+module ZPNG
+  class Pixels
+    include Enumerable
+
+    def initialize image
+      @image = image
+    end
+
+    def each
+      @image.height.times do |y|
+        @image.width.times do |x|
+          yield @image[x,y]
+        end
+      end
+    end
+
+    def == other
+      self.to_a == other.to_a
+    end
+
+    def uniq
+      self.to_a.uniq
+    end
+  end
+end

data/lib/zpng/scan_line.rb

@@ -8,6 +8,7 @@ module ZPNG
     FILTER_PAETH          = 4
 
     attr_accessor :image, :idx, :filter, :offset, :bpp
+    attr_writer :decoded_bytes
 
     def initialize image, idx
       @image,@idx = image,idx
@@ -77,49 +78,63 @@ module ZPNG
       decode_pixel(x)
     end
 
-    def []= x, newcolor
-      if image.hdr.palette_used?
-        color_idx = image.palette.find_or_add(newcolor)
-        raise "no color #{newcolor.inspect} in palette" unless color_idx
-      elsif image.grayscale?
-        color_idx = newcolor.to_grayscale
-      end
+    def []= x, color
+      case image.hdr.color
+      when COLOR_INDEXED                # ALLOWED_DEPTHS: 1, 2, 4, 8
+        color_idx = image.palette.find_or_add(color)
+        raise "no color #{color.inspect} in palette" unless color_idx
 
-      case @bpp
-      when 1,2,4
-        pos = x*@bpp/8
-        b = decoded_bytes[pos].ord
         mask  = 2**@bpp-1
         shift = 8-(x%(8/@bpp)+1)*@bpp
         raise "invalid shift #{shift}" if shift < 0 || shift > 7
 
-#        printf "[d] %s x=%2d bpp=%d pos=%d mask=%08b shift=%d decoded_bytes=#{decoded_bytes.inspect}\n", self.to_s, x, @bpp, pos, mask, shift
-
+        pos = x*@bpp/8
+        b = decoded_bytes[pos].ord
         b = (b & (0xff-(mask<<shift))) | ((color_idx & mask) << shift)
         decoded_bytes[pos] = b.chr
+        # TODO: transparency in TRNS
 
-      when 8
-        if image.hdr.palette_used?
-          decoded_bytes[x] = color_idx.chr
+      when COLOR_GRAYSCALE              # ALLOWED_DEPTHS: 1, 2, 4, 8, 16
+        raw = color.to_depth(@bpp).to_grayscale
+        pos = x*@bpp/8
+        if @bpp == 16
+          decoded_bytes[pos,2] = [raw].pack('n')
         else
-          decoded_bytes[x] = ((newcolor.r + newcolor.g + newcolor.b)/3).chr
+          mask  = 2**@bpp-1
+          shift = 8-(x%(8/@bpp)+1)*@bpp
+          raise "invalid shift #{shift}" if shift < 0 || shift > 7
+          b = decoded_bytes[pos].ord
+          b = (b & (0xff-(mask<<shift))) | ((raw & mask) << shift)
+          decoded_bytes[pos] = b.chr
         end
-      when 16
-        if image.hdr.palette_used? && image.hdr.alpha_used?
-          decoded_bytes[x*2] = color_idx.chr
-          decoded_bytes[x*2+1] = (newcolor.alpha || 0xff).chr
-        elsif image.grayscale? && image.hdr.alpha_used?
-          decoded_bytes[x*2] = newcolor.to_grayscale.chr
-          decoded_bytes[x*2+1] = (newcolor.alpha || 0xff).chr
-        else
-          raise "unexpected colormode #{image.hdr.inspect}"
+        # TODO: transparency in TRNS
+
+      when COLOR_RGB                    # ALLOWED_DEPTHS: 8, 16
+        case @bpp
+        when 24; decoded_bytes[x*3,3] = color.to_depth(8).to_a.pack('C3')
+        when 48; decoded_bytes[x*6,6] = color.to_depth(16).to_a.pack('n3')
+        else raise "unexpected bpp #@bpp"
         end
-      when 24
-        decoded_bytes[x*3,3] = [newcolor.r, newcolor.g, newcolor.b].map(&:chr).join
-      when 32
-        decoded_bytes[x*4,4] = [newcolor.r, newcolor.g, newcolor.b, newcolor.a].map(&:chr).join
-      else raise "unsupported bpp #{@bpp}"
-      end
+        # TODO: transparency in TRNS
+
+      when COLOR_GRAY_ALPHA             # ALLOWED_DEPTHS: 8, 16
+        case @bpp
+        when 16; decoded_bytes[x*2,2] = color.to_depth(8).to_gray_alpha.pack('C2')
+        when 32; decoded_bytes[x*4,4] = color.to_depth(16).to_gray_alpha.pack('n2')
+        else raise "unexpected bpp #@bpp"
+        end
+
+      when COLOR_RGBA                   # ALLOWED_DEPTHS: 8, 16
+        case @bpp
+        when 32; decoded_bytes[x*4,4] = color.to_depth(8).to_a.pack('C4')
+        when 64; decoded_bytes[x*8,8] = color.to_depth(16).to_a.pack('n4')
+        else raise "unexpected bpp #@bpp"
+        end
+
+      else
+        raise "unexpected color mode #{image.hdr.color}"
+
+      end # case image.hdr.color
     end
 
     def decode_pixel x
@@ -132,56 +147,82 @@ module ZPNG
           decoded_bytes[x*@bpp/8]
         end
 
-      color, alpha =
-        case @bpp
-        when 1,2,4
-          mask  = 2**@bpp-1
-          shift = 8-(x%(8/@bpp)+1)*@bpp
-          raise "invalid shift #{shift}" if shift < 0 || shift > 7
-          [(raw.ord >> shift) & mask, nil]
-        when 8
-          [raw.ord, nil]
-        when 16
-          if image.alpha_used?
-            raw.unpack 'C2'
-          else
-            # 16-bit grayscale
-            raw.unpack 'n'
-          end
-        when 24
-          # RGB
-          return Color.new(*raw.unpack('C3'))
-        when 32
-          if image.grayscale? && image.alpha_used?
-            # 16-bit grayscale + 16-bit alpha
-            raw.unpack 'n2'
-          else
-            # RGBA
-            return Color.new(*raw.unpack('C4'))
+      case image.hdr.color
+      when COLOR_INDEXED                # ALLOWED_DEPTHS: 1, 2, 4, 8
+        mask  = 2**@bpp-1
+        shift = 8-(x%(8/@bpp)+1)*@bpp
+        raise "invalid shift #{shift}" if shift < 0 || shift > 7
+        idx = (raw.ord >> shift) & mask
+        if image.trns
+          # transparency from tRNS chunk
+          # For color type 3 (indexed color), the tRNS chunk contains a series of one-byte alpha values,
+          # corresponding to entries in the PLTE chunk:
+          #
+          #   Alpha for palette index 0:  1 byte
+          #   Alpha for palette index 1:  1 byte
+          #   ...
+          #
+          color = image.palette[idx].dup
+          if color.alpha = image.trns.data[idx]
+            # if it's not NULL - convert it from char to int,
+            # otherwise it means fully opaque color, as well as NULL alpha in ZPNG::Color
+            color.alpha = color.alpha.ord
           end
-        when 48
-          # RGB 16 bits per sample
-          return Color.new(*raw.unpack('n3'), :depth => 16)
-        when 64
-          # RGB 16 bits per sample + 16-bit alpha
-          return Color.new(*raw.unpack('n4'), :depth => 16, :alpha_depth => 16)
+          return color
         else
-          raise "unexpected bpp #{@bpp}"
+          # no transparency
+          return image.palette[idx]
+        end
+
+      when COLOR_GRAYSCALE              # ALLOWED_DEPTHS: 1, 2, 4, 8, 16
+        c = if @bpp == 16
+              raw.unpack('n')[0]
+            else
+              mask  = 2**@bpp-1
+              shift = 8-(x%(8/@bpp)+1)*@bpp
+              raise "invalid shift #{shift}" if shift < 0 || shift > 7
+              (raw.ord >> shift) & mask
+            end
+
+        color = Color.from_grayscale(c, :depth => @bpp) # only in this color mode depth == bpp
+        color.alpha = image._alpha_color(color)
+        return color
+
+      when COLOR_RGB                    # ALLOWED_DEPTHS: 8, 16
+        color =
+          case @bpp
+          when 24                     # RGB  8 bits per sample = 24bpp
+            Color.new(*raw.unpack('C3'))
+          when 48                     # RGB 16 bits per sample = 48bpp
+            Color.new(*raw.unpack('n3'), :depth => 16)
+          else raise "COLOR_RGB unexpected bpp #@bpp"
+          end
+
+        color.alpha = image._alpha_color(color)
+        return color
+
+      when COLOR_GRAY_ALPHA             # ALLOWED_DEPTHS: 8, 16
+        case @bpp
+        when 16                         #  8-bit grayscale +  8-bit alpha
+          return Color.from_grayscale(*raw.unpack('C2'))
+        when 32                         # 16-bit grayscale + 16-bit alpha
+          return Color.from_grayscale(*raw.unpack('n2'), :depth => 16)
+        else raise "COLOR_GRAY_ALPHA unexpected bpp #@bpp"
+        end
+
+      when COLOR_RGBA                   # ALLOWED_DEPTHS: 8, 16
+        case @bpp
+        when 32                         # RGBA  8-bit/sample
+          return Color.new(*raw.unpack('C4'))
+        when 64                         # RGBA 16-bit/sample
+          return Color.new(*raw.unpack('n4'), :depth => 16 )
+        else raise "COLOR_RGBA unexpected bpp #@bpp"
         end
 
-      if image.grayscale?
-        Color.from_grayscale(color,
-                             :alpha => alpha,
-                             :depth => image.hdr.depth,
-                             :alpha_depth => image.alpha_used? ? image.hdr.depth : 0
-                            )
-      elsif image.palette
-        color = image.palette[color]
-        color.alpha = alpha
-        color
       else
-        raise "cannot decode color"
-      end
+        raise "unexpected color mode #{image.hdr.color}"
+
+      end # case img.hdr.color
     end
 
     def decoded_bytes
@@ -211,6 +252,19 @@ module ZPNG
     end
 
     private
+
+    def prev_scanline_byte x
+      if image.interlaced?
+        # When the image is interlaced, each pass of the interlace pattern is
+        # treated as an independent image for filtering purposes
+        image.adam7.pass_start?(@idx) ? 0 : image.scanlines[@idx-1].decoded_bytes[x].ord
+      elsif @idx > 0
+        image.scanlines[@idx-1].decoded_bytes[x].ord
+      else
+        0
+      end
+    end
+
     def decode_byte x, b0, bpp1
       raw = @image.imagedata[@offset+x+1]
 
@@ -220,27 +274,25 @@ module ZPNG
       end
 
       case @filter
-      when FILTER_NONE  # 0
+      when FILTER_NONE    # 0
         raw
 
-      when FILTER_SUB   # 1
+      when FILTER_SUB     # 1
         return raw unless b0
         ((raw.ord + b0.ord) & 0xff).chr
 
-      when FILTER_UP    # 2
-        return raw if @idx == 0
-        prev = @image.scanlines[@idx-1].decoded_bytes[x]
-        ((raw.ord + prev.ord) & 0xff).chr
+      when FILTER_UP      # 2
+        ((raw.ord + prev_scanline_byte(x)) & 0xff).chr
 
       when FILTER_AVERAGE # 3
         prev = (b0 && b0.ord) || 0
-        prior = (@idx > 0) ? @image.scanlines[@idx-1].decoded_bytes[x].ord : 0
+        prior = prev_scanline_byte(x)
         ((raw.ord + (prev + prior)/2) & 0xff).chr
 
-      when FILTER_PAETH # 4
+      when FILTER_PAETH   # 4
         pa = (b0 && b0.ord) || 0
-        pb = (@idx > 0) ? @image.scanlines[@idx-1].decoded_bytes[x].ord : 0
-        pc = (b0 && @idx > 0) ? @image.scanlines[@idx-1].decoded_bytes[x-bpp1].ord : 0
+        pb = prev_scanline_byte(x)
+        pc = b0 ? prev_scanline_byte(x-bpp1) : 0
         ((raw.ord + paeth_predictor(pa, pb, pc)) & 0xff).chr
       else
         raise "invalid ScanLine filter #{@filter}"

data/lib/zpng/string_ext.rb

@@ -4,7 +4,15 @@ class String
   [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white].each do |color|
     unless instance_methods.include?(color)
       define_method color do
-        self.send(:color, color)
+        color(color)
+      end
+    end
+  end
+
+  [:gray, :grey].each do |color|
+    unless instance_methods.include?(color)
+      define_method color do
+        color(:black).bright
       end
     end
   end

data/lib/zpng/text_chunk.rb

@@ -0,0 +1,75 @@
+module ZPNG
+  class TextChunk < Chunk
+    attr_accessor :keyword, :text
+
+    def inspect verbosity = 10
+      vars = %w'keyword text language translated_keyword cmethod cflag'
+      vars -= %w'text translated_keyword' if verbosity <=0
+      super.sub(/ *>$/,'') + ", " +
+        vars.map do |var|
+          t = instance_variable_get("@#{var}")
+          unless t.is_a?(Fixnum)
+            t = t.to_s
+            t = t[0..20] + "..." if t.size > 20
+          end
+          if t.nil? || t == ''
+            nil
+          else
+            "#{var.to_s.tr('@','')}=#{t.inspect}"
+          end
+        end.compact.join(", ") + ">"
+    end
+
+    def to_hash
+      { :keyword => keyword, :text => text}
+    end
+  end
+
+  class Chunk
+    class TEXT < TextChunk
+      def initialize *args
+        super
+        @keyword,@text = data.unpack('Z*a*')
+      end
+    end
+
+    class ZTXT < TextChunk
+      attr_accessor :cmethod # compression method
+      def initialize *args
+        super
+        @keyword,@cmethod,@text = data.unpack('Z*Ca*')
+        # current only @cmethod value is 0 - deflate
+        if @text
+          @text = Zlib::Inflate.inflate(@text)
+        end
+      end
+    end
+
+    class ITXT < TextChunk
+      attr_accessor :cflag, :cmethod # compression flag & method
+      attr_accessor :language, :translated_keyword
+      def initialize *args
+        super
+        # The text, unlike the other strings, is not null-terminated; its length is implied by the chunk length.
+        # http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html#C.iTXt
+        @keyword, @cflag, @cmethod, @language, @translated_keyword, @text = data.unpack('Z*CCZ*Z*a*')
+        if @cflag == 1 && @cmethod == 0
+          @text = Zlib::Inflate.inflate(@text)
+        end
+        if @text
+          @text.force_encoding('utf-8') rescue nil
+        end
+        if @translated_keyword
+          @translated_keyword.force_encoding('utf-8') rescue nil
+        end
+      end
+
+      def to_hash
+        super.tap do |h|
+          h[:language] = @language if @language || !@language.empty?
+          h[:translated_keyword] = @translated_keyword if @translated_keyword || !@translated_keyword.empty?
+        end
+      end
+    end
+  end
+end

data/spec/adam7_spec.rb

@@ -59,3 +59,27 @@ describe ZPNG::Adam7Decoder do
     end
   end
 end
+
+PNGSuite.each("???i*.png") do |fname_i|
+  fname_n = File.basename(fname_i)
+  fname_n[3] = 'n'
+  fname_n = File.join(File.dirname(fname_i), fname_n)
+  next unless File.exist?(fname_n)
+
+  describe fname_i.sub(%r|\A#{Regexp::escape(Dir.getwd)}/?|, '') do
+    it "should be pixel-by-pixel identical to " + fname_n.sub(%r|\A#{Regexp::escape(Dir.getwd)}/?|, '') do
+      interlaced = ZPNG::Image.load(fname_i)
+      normal     = ZPNG::Image.load(fname_n)
+
+      normal.pixels.to_a.should == interlaced.pixels.to_a
+
+      interlaced.each_pixel do |color,x,y|
+        normal[x,y].should == color
+      end
+
+      normal.each_pixel do |color,x,y|
+        interlaced[x,y].should == color
+      end
+    end
+  end
+end