zpng 0.2.0 → 0.2.1

data/lib/zpng/color.rb

@@ -1,7 +1,8 @@
 module ZPNG
   class Color
-    attr_accessor :r, :g, :b, :a
-    attr_accessor :depth, :alpha_depth
+    attr_accessor :r, :g, :b
+    attr_reader   :a
+    attr_accessor :depth
 
     include DeepCopyable
 
@@ -9,16 +10,18 @@ module ZPNG
       h = a.last.is_a?(Hash) ? a.pop : {}
       @r,@g,@b,@a = *a
 
-      # default ALPHA = 0xff - opaque
-      @a ||= h[:alpha] || 0xff
-
       # default sample depth for r,g,b and alpha = 8 bits
       @depth       = h[:depth]       || 8
-      @alpha_depth = h[:alpha_depth] || @depth
+
+      # default ALPHA = 0xff - opaque
+      @a ||= h[:alpha] || (2**@depth-1)
     end
 
-    alias :alpha :a
-    def alpha= a; @a=a; end
+    def a= a
+      @a = a || (2**@depth-1)   # NULL alpha means fully opaque
+    end
+    alias :alpha  :a
+    alias :alpha= :a=
 
     BLACK = Color.new(0  ,  0,  0)
     WHITE = Color.new(255,255,255)
@@ -32,6 +35,8 @@ module ZPNG
     PURPLE= MAGENTA =
             Color.new(255,  0,255)
 
+    TRANSPARENT = Color.new(0,0,0,0)
+
     ANSI_COLORS = [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white]
 
     #ASCII_MAP = %q_ .`,-:;~"!<+*^(LJ=?vctsxj12FuoCeyPSah5wVmXA4G9$OR0MQNW#&%@_
@@ -51,6 +56,7 @@ module ZPNG
 
     # euclidian distance - http://en.wikipedia.org/wiki/Euclidean_distance
     def euclidian other_color
+      # TODO: different depths
       r  = (self.r.to_i - other_color.r.to_i)**2
       r += (self.g.to_i - other_color.g.to_i)**2
       r += (self.b.to_i - other_color.b.to_i)**2
@@ -58,7 +64,8 @@ module ZPNG
     end
 
     def white?
-      r == 0xff && g == 0xff && b == 0xff
+      max = 2**depth-1
+      r == max && g == max && b == max
     end
 
     def black?
@@ -69,26 +76,51 @@ module ZPNG
       a == 0
     end
 
+    def opaque?
+      a.nil? || a == 2**depth-1
+    end
+
     def to_grayscale
       (r+g+b)/3
     end
 
-    def self.from_grayscale value, alpha_or_hash = nil
-      Color.new value,value,value, alpha_or_hash
+    def to_gray_alpha
+      [to_grayscale, alpha]
+    end
+
+    # from_grayscale level
+    # from_grayscale level,        :depth => 16
+    # from_grayscale level, alpha
+    # from_grayscale level, alpha, :depth => 16
+    def self.from_grayscale value, *args
+      Color.new value,value,value, *args
+    end
+
+    ########################################################
+    # simple conversions
+
+    def to_i
+      ((a||0) << 24) + ((r||0) << 16) + ((g||0) << 8) + (b||0)
     end
 
     def to_s
       "%02X%02X%02X" % [r,g,b]
     end
 
+    def to_a
+      [r, g, b, a]
+    end
+
     ########################################################
+    # complex conversions
 
-    # try to convert to pseudographics
+    # try to convert to one pseudographics ASCII character
     def to_ascii map=ASCII_MAP
       #p self
       map[self.to_grayscale*(map.size-1)/(2**@depth-1), 1]
     end
 
+    # convert to ANSI color name
     def to_ansi
       return to_depth(8).to_ansi if depth != 8
       a = ANSI_COLORS.map{|c| self.class.const_get(c.to_s.upcase) }
@@ -96,6 +128,7 @@ module ZPNG
       ANSI_COLORS[a.index(a.min)]
     end
 
+    # HTML/CSS color in notation like #33aa88
     def to_css
       return to_depth(8).to_css if depth != 8
       "#%02X%02X%02X" % [r,g,b]
@@ -104,30 +137,22 @@ module ZPNG
 
     ########################################################
 
-    def to_i
-      ((a||0) << 24) + ((r||0) << 16) + ((g||0) << 8) + (b||0)
-    end
-
     # change bit depth, return new Color
     def to_depth new_depth
-      c = Color.new :depth => new_depth
+      return self if depth == new_depth
+
+      color = Color.new :depth => new_depth
       if new_depth > self.depth
-        %w'r g b'.each do |part|
-          color = self.send(part)
-          if color%2 == 0
-            color <<= (new_depth-self.depth)
-          else
-            (new_depth-self.depth).times{ color = color*2 + 1 }
-          end
-          c.send("#{part}=", color)
+        %w'r g b a'.each do |part|
+          color.send("#{part}=", (2**new_depth-1)/(2**depth-1)*self.send(part))
         end
       else
         # new_depth < self.depth
-        %w'r g b'.each do |part|
-          c.send("#{part}=", self.send(part)>>(self.depth-new_depth))
+        %w'r g b a'.each do |part|
+          color.send("#{part}=", self.send(part)>>(self.depth-new_depth))
         end
       end
-      c
+      color
     end
 
     def inspect
@@ -136,16 +161,46 @@ module ZPNG
         s << " r=" + (r ? "%04x" % r : "????")
         s << " g=" + (g ? "%04x" % g : "????")
         s << " b=" + (b ? "%04x" % b : "????")
+        s << " alpha=%04x" % alpha if alpha && alpha != 0xffff
       else
         s << " #"
         s << (r ? "%02x" % r : "??")
         s << (g ? "%02x" % g : "??")
         s << (b ? "%02x" % b : "??")
+        s << " alpha=%02x" % alpha if alpha && alpha != 0xff
       end
-      s << " a=#{a}" if a && alpha_depth != 0
       s << " depth=#{depth}" if depth != 8
-      s << " alpha_depth=#{alpha_depth}" if alpha_depth != 8 && alpha_depth != 0
       s << ">"
     end
+
+    # compare with other color
+    def == c
+      return false unless c.is_a?(Color)
+      c1,c2 =
+        if self.depth > c.depth
+          [self, c.to_depth(self.depth)]
+        else
+          [self.to_depth(c.depth), c]
+        end
+      c1.r == c2.r && c1.g == c2.g && c1.b == c2.b && c1.a == c2.a
+    end
+    alias :eql? :==
+
+    # compare with other color
+    def <=> c
+      c1,c2 =
+        if self.depth > c.depth
+          [self, c.to_depth(self.depth)]
+        else
+          [self.to_depth(c.depth), c]
+        end
+      r = c1.to_grayscale <=> c2.to_grayscale
+      r == 0 ? (c1.to_a <=> c2.to_a) : r
+    end
+
+    # for Array.uniq()
+    def hash
+      self.to_i
+    end
   end
 end

data/lib/zpng/hexdump.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+module ZPNG
+  module Hexdump
+
+    def hexdump *args, &block
+      print Hexdump.dump(*args, &block)
+    end
+
+    class << self
+      def dump data, h = {}
+        offset = h[:offset] || 0
+        add    = h[:add]    || 0
+        size   = h[:size]   || (data.size-offset)
+        tail   = h[:tail]   || "\n"
+        width  = h[:width]  || 0x10                 # row width, in bytes
+
+        h[:show_offset] = true unless h.key?(:show_offset)
+        h[:dedup]       = true unless h.key?(:dedup)
+
+        size = data.size-offset if size+offset > data.size
+
+        r = ''; prevhex = ''; c = nil; prevdup = false
+        while true
+          ascii = ''; hex = ''
+          width.times do |i|
+            hex << ' ' if i%8==0 && i>0
+            if c = ((size > 0) && data[offset+i])
+              hex << "%02x " % c.ord
+              ascii << ((32..126).include?(c.ord) ? c : '.')
+            else
+              hex << '   '
+              ascii << ' '
+            end
+            size-=1
+          end
+
+          if h[:dedup] && hex == prevhex
+            row = "*"
+            yield(row, offset+add, ascii) if block_given?
+            r << row << "\n" unless prevdup
+            prevdup = true
+          else
+            row = (h[:show_offset] ?  ("%08x: " % (offset + add)) : '') + hex + ' |' + ascii + "|"
+            yield(row, offset+add, ascii) if block_given?
+            r << row << "\n"
+            prevdup = false
+          end
+
+          offset += width
+          prevhex = hex
+          break if size <= 0
+        end
+        if h[:show_offset] && prevdup
+          row = "%08x: " % (offset + add)
+          yield(row) if block_given?
+          r << row
+        end
+        r.chomp + tail
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  h = {}
+  case ARGV.size
+    when 0
+      puts "gimme fname [offset] [size]"
+      exit
+    when 1
+      fname = ARGV[0]
+    when 2
+      fname = ARGV[0]
+      h[:offset] = ARGV[1].to_i
+    when 3
+      fname = ARGV[0]
+      h[:offset] = ARGV[1].to_i
+      h[:size]   = ARGV[2].to_i
+  end
+  File.open(fname,"rb") do |f|
+    f.seek h[:offset] if h[:offset]
+    @data = f.read(h[:size])
+  end
+  puts ZPNG::Hexdump.dump(@data)
+end

data/lib/zpng/image.rb

@@ -1,6 +1,6 @@
 module ZPNG
   class Image
-    attr_accessor :data, :header, :chunks, :scanlines, :imagedata, :palette
+    attr_accessor :data, :header, :chunks, :scanlines, :imagedata
     alias :hdr :header
 
     include DeepCopyable
@@ -28,13 +28,16 @@ module ZPNG
       @adam7 ||= Adam7Decoder.new(self)
     end
 
-    # load image from file
-    def self.load fname
-      open(fname,"rb") do |f|
-        Image.new(f)
+    class << self
+      # load image from file
+      def load fname
+        open(fname,"rb") do |f|
+          self.new(f)
+        end
       end
+      alias :load_file :load
+      alias :from_file :load # as in ChunkyPNG
     end
-    alias :load_file :load
 
     # save image to file
     def save fname
@@ -52,10 +55,19 @@ module ZPNG
 
     def _from_hash h
       @new_image = true
-      @chunks << (@header  = Chunk::IHDR.new(h))
+      @chunks << (@header = Chunk::IHDR.new(h))
       if @header.palette_used?
-        @chunks << (@palette = Chunk::PLTE.new)
-        @palette[0] = h[:background] || h[:bg] || Color::BLACK # add default bg color
+        if h.key?(:palette)
+          if h[:palette]
+            @chunks << h[:palette]
+          else
+            # :palette => nil
+            # assume palette will be added later
+          end
+        else
+          @chunks << Chunk::PLTE.new
+          palette[0] = h[:background] || h[:bg] || Color::BLACK # add default bg color
+        end
       end
     end
 
@@ -86,8 +98,6 @@ module ZPNG
         case chunk
         when Chunk::IHDR
           @header = chunk
-        when Chunk::PLTE
-          @palette = chunk
         when Chunk::IEND
           break
         end
@@ -100,12 +110,58 @@ module ZPNG
     end
 
     public
-    def dump
-      @chunks.each do |chunk|
-        puts "[.] #{chunk.inspect} #{chunk.crc_ok? ? 'CRC OK'.green : 'CRC ERROR'.red}"
-      end
+
+    # internal helper method for color types 0 (grayscale) and 2 (truecolor)
+    def _alpha_color color
+      return nil unless trns
+
+      # For color type 0 (grayscale), the tRNS chunk contains a single gray level value, stored in the format:
+      #
+      #   Gray:  2 bytes, range 0 .. (2^bitdepth)-1
+      #
+      # For color type 2 (truecolor), the tRNS chunk contains a single RGB color value, stored in the format:
+      #
+      #   Red:   2 bytes, range 0 .. (2^bitdepth)-1
+      #   Green: 2 bytes, range 0 .. (2^bitdepth)-1
+      #   Blue:  2 bytes, range 0 .. (2^bitdepth)-1
+      #
+      # (If the image bit depth is less than 16, the least significant bits are used and the others are 0)
+      # Pixels of the specified gray level are to be treated as transparent (equivalent to alpha value 0);
+      # all other pixels are to be treated as fully opaque ( alpha = (2^bitdepth)-1 )
+
+      @alpha_color ||=
+        case hdr.color
+        when COLOR_GRAYSCALE
+          v = trns.data.unpack('n')[0] & (2**hdr.depth-1)
+          Color.from_grayscale(v, :depth => hdr.depth)
+        when COLOR_RGB
+          a = trns.data.unpack('n3').map{ |v| v & (2**hdr.depth-1) }
+          Color.new(*a, :depth => hdr.depth)
+        else
+          raise "color2alpha only intended for GRAYSCALE & RGB color modes"
+        end
+
+      color == @alpha_color ? 0 : (2**hdr.depth-1)
+    end
+
+    public
+
+    ###########################################################################
+    # chunks access
+
+    def trns
+      # not used "@trns ||= ..." here b/c it will call find() each time of there's no TRNS chunk
+      defined?(@trns) ? @trns : (@trns=@chunks.find{ |c| c.is_a?(Chunk::TRNS) })
     end
 
+    def plte
+      @plte ||= @chunks.find{ |c| c.is_a?(Chunk::PLTE) }
+    end
+    alias :palette :plte
+
+    ###########################################################################
+    # image attributes
+
     def bpp
       @header && @header.bpp
     end
@@ -139,6 +195,10 @@ module ZPNG
         end
     end
 
+    def metadata
+      @metadata ||= Metadata.new(self)
+    end
+
     def [] x, y
       x,y = adam7.convert_coords(x,y) if interlaced?
       scanlines[y][x]
@@ -153,7 +213,7 @@ module ZPNG
     # we must decode all scanlines before doing any modifications
     # or scanlines decoded AFTER modification of UPPER ones will be decoded wrong
     def decode_all_scanlines
-      return if @all_scanlines_decoded
+      return if @all_scanlines_decoded || new_image?
       @all_scanlines_decoded = true
       scanlines.each(&:decode!)
     end
@@ -201,7 +261,8 @@ module ZPNG
     end
 
     def export
-      imagedata # fill @imagedata, if not already filled
+      # fill @imagedata, if not already filled
+      imagedata unless new_image?
 
       # delete old IDAT chunks
       @chunks.delete_if{ |c| c.is_a?(Chunk::IDAT) }
@@ -255,6 +316,16 @@ module ZPNG
       deep_copy.crop!(params)
     end
 
+    def pixels
+      Pixels.new(self)
+    end
+
+    def == other_image
+      width  == other_image.width &&
+      height == other_image.height &&
+      pixels == other_image.pixels
+    end
+
     def each_pixel &block
       height.times do |y|
         width.times do |x|
@@ -267,22 +338,29 @@ module ZPNG
     # OR returns self if no need to deinterlace
     def deinterlace
       return self unless interlaced?
-      require 'pp'
-      pp chunks
 
       # copy all but 'interlace' header params
       h = Hash[*%w'width height depth color compression filter'.map{ |k| [k.to_sym, hdr.send(k)] }.flatten]
-      new_img = Image.new h
+
+      # don't auto-add palette chunk
+      h[:palette] = nil
+
+      # create new img
+      new_img = self.class.new h
+
+      # copy all but hdr/imagedata/end chunks
       chunks.each do |chunk|
         next if chunk.is_a?(Chunk::IHDR)
         next if chunk.is_a?(Chunk::IDAT)
         next if chunk.is_a?(Chunk::IEND)
         new_img.chunks << chunk.deep_copy
       end
+
+      # pixel-by-pixel copy
       each_pixel do |c,x,y|
         new_img[x,y] = c
       end
-      p new_img.scanlines
+
       new_img
     end
   end