zpng 0.0.2 → 0.1.0

data/lib/zpng/cli.rb

@@ -6,8 +6,8 @@ require 'pp'
 class ZPNG::CLI
 
   ACTIONS = {
-    'info'      => 'General image info',
     'chunks'    => 'Show file chunks (default)',
+    %w'i info'      => 'General image info (default)',
     'ascii'     => 'Try to display image as ASCII (works best with monochrome images)',
     'scanlines' => 'Show scanlines info',
     'palette'   => 'Show palette'
@@ -22,7 +22,7 @@ class ZPNG::CLI
     @actions = []
     @options = { :verbose => 0 }
     optparser = OptionParser.new do |opts|
-      opts.banner = "Usage: zpng [options]"
+      opts.banner = "Usage: zpng [options] filename.png"
 
       opts.on "-v", "--verbose", "Run verbosely (can be used multiple times)" do |v|
         @options[:verbose] += 1
@@ -32,12 +32,24 @@ class ZPNG::CLI
       end
 
       ACTIONS.each do |t,desc|
-        opts.on *[ "-#{t[0].upcase}", "--#{t}", desc, eval("lambda{ |_| @actions << :#{t} }") ]
+        if t.is_a?(Array)
+          opts.on *[ "-#{t[0]}", "--#{t[1]}", desc, eval("lambda{ |_| @actions << :#{t[1]} }") ]
+        else
+          opts.on *[ "-#{t[0].upcase}", "--#{t}", desc, eval("lambda{ |_| @actions << :#{t} }") ]
+        end
       end
 
-      opts.on "-E", "--extract-chunk id" do |id|
+      opts.on "-E", "--extract-chunk ID", "extract a single chunk" do |id|
         @actions << [:extract_chunk, id.to_i]
       end
+      opts.on "-U", "--unpack-imagedata", "unpack Image Data (IDAT) chunk(s), output to stdout" do
+        @actions << :unpack_imagedata
+      end
+
+      opts.on "-c", "--crop GEOMETRY", "crop image, {WIDTH}x{HEIGHT}+{X}+{Y},",
+      "puts results on stdout unless --ascii given" do |x|
+        @actions << [:crop, x]
+      end
     end
 
     if (argv = optparser.parse(@argv)).empty?
@@ -80,12 +92,25 @@ class ZPNG::CLI
     end
   end
 
+  def unpack_imagedata
+    print @img.imagedata
+  end
+
+  def crop geometry
+    unless geometry =~ /\A(\d+)x(\d+)\+(\d+)\+(\d+)\Z/i
+      STDERR.puts "[!] invalid geometry #{geometry.inspect}, must be WxH+X+Y, like 100x100+10+10"
+      exit 1
+    end
+    @img.crop! :width => $1.to_i, :height => $2.to_i, :x => $3.to_i, :y => $4.to_i
+    print @img.export unless @actions.include?(:ascii)
+  end
+
   def load_file fname
     @img = ZPNG::Image.new fname
   end
 
   def info
-    puts "[.] image size #{@img.width}x#{@img.height}"
+    puts "[.] image size #{@img.width || '?'}x#{@img.height || '?'}"
     puts "[.] uncompressed imagedata size = #{@img.imagedata.size} bytes"
     puts "[.] palette = #{@img.palette}" if @img.palette
   end

data/lib/zpng/color.rb

@@ -1,7 +1,13 @@
 module ZPNG
   class Color < Struct.new(:r,:g,:b,:a)
 
+    def initialize *args
+      super
+      self.a ||= 0xff
+    end
+
     alias :alpha :a
+    def alpha= v; self.a = v; end
 
     BLACK = Color.new(0,0,0,0xff)
     WHITE = Color.new(0xff,0xff,0xff,0xff)
@@ -14,12 +20,36 @@ module ZPNG
       r == 0 && g == 0 && b == 0
     end
 
+    def transparent?
+      a == 0
+    end
+
     def to_grayscale
       (r+g+b)/3
     end
 
+    def self.from_grayscale value, alpha = nil
+      Color.new value,value,value, alpha
+    end
+
     def to_s
       "%02X%02X%02X" % [r,g,b]
     end
+
+    def to_i
+      ((a||0) << 24) + ((r||0) << 16) + ((g||0) << 8) + (b||0)
+    end
+
+    def inspect
+      if r && g && b && a
+        "#<ZPNG::Color #%02x%02x%02x a=%d>" % [r,g,b,a]
+      else
+        rs = r ? "%02x" % r : "??"
+        gs = g ? "%02x" % g : "??"
+        bs = b ? "%02x" % b : "??"
+        as = a ? "%d"   % a : "?"
+        "#<ZPNG::Color #%s%s%s%s a=%s>" % [rs,gs,bs,as]
+      end
+    end
   end
 end

data/lib/zpng/image.rb

@@ -5,7 +5,55 @@ module ZPNG
 
     PNG_HDR = "\x89PNG\x0d\x0a\x1a\x0a"
 
-    def initialize x = nil
+    def initialize x
+      @chunks = []
+      case x
+        when IO
+          _from_string x.read
+        when String
+          _from_string x
+        when Hash
+          _from_hash x
+        else
+          raise "unsupported input data type #{x.class}"
+      end
+      if palette && hdr && hdr.depth
+        palette.max_colors = 2**hdr.depth
+      end
+    end
+
+    # load image from file
+    def self.load fname
+      open(fname,"rb") do |f|
+        Image.new(f)
+      end
+    end
+    alias :load_file :load
+
+    # save image to file
+    def save fname
+      File.open(fname,"wb"){ |f| f << export }
+    end
+
+    # flag that image is just created, and NOT loaded from file
+    # as in Rails' ActiveRecord::Base#new_record?
+    def new_image?
+      @new_image
+    end
+    alias :new? :new_image?
+
+    private
+
+    def _from_hash h
+      @new_image = true
+      @chunks << (@header  = Chunk::IHDR.new(h))
+      if @header.palette_used?
+        @chunks << (@palette = Chunk::PLTE.new)
+        @palette[0] = h[:bg] || Color::BLACK # add default bg color
+      end
+    end
+
+    def _from_string x
       if x
         if x[PNG_HDR]
           # raw image data
@@ -23,7 +71,6 @@ module ZPNG
 
       io = StringIO.new(data)
       io.seek PNG_HDR.size
-      @chunks = []
       while !io.eof?
         chunk = Chunk.from_stream(io)
         chunk.idx = @chunks.size
@@ -44,6 +91,7 @@ module ZPNG
       end
     end
 
+    public
     def dump
       @chunks.each do |chunk|
         puts "[.] #{chunk.inspect} #{chunk.crc_ok? ? 'CRC OK'.green : 'CRC ERROR'.red}"
@@ -58,13 +106,21 @@ module ZPNG
       @header && @header.height
     end
 
+    def grayscale?
+      @header && @header.grayscale?
+    end
+
     def imagedata
-      if @header
-        raise "only non-interlaced mode is supported for imagedata" if @header.interlace != 0
-      else
-        puts "[?] no image header, assuming non-interlaced RGB".yellow
-      end
-      @imagedata ||= Zlib::Inflate.inflate(@chunks.find_all{ |c| c.type == "IDAT" }.map(&:data).join)
+      @imagedata ||=
+        begin
+          if @header
+            raise "only non-interlaced mode is supported for imagedata" if @header.interlace != 0
+          else
+            puts "[?] no image header, assuming non-interlaced RGB".yellow
+          end
+          data = @chunks.find_all{ |c| c.is_a?(Chunk::IDAT) }.map(&:data).join
+          (data && data.size > 0) ? Zlib::Inflate.inflate(data) : ''
+        end
     end
 
     def [] x, y
@@ -72,30 +128,36 @@ module ZPNG
     end
 
     def []= x, y, newpixel
-      # we must decode all scanlines before doing any modifications
-      # or scanlines decoded AFTER modification of UPPER ones will be decoded wrong
-      _decode_all_scanlines unless @_all_scanlines_decoded
+      decode_all_scanlines
       scanlines[y][x] = newpixel
     end
 
-    def _decode_all_scanlines
+    # 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
+      @all_scanlines_decoded = true
       scanlines.each(&:decode!)
-      @_all_scanlines_decoded = true
     end
 
     def scanlines
       @scanlines ||=
         begin
           r = []
-          height.times do |i|
+          height.to_i.times do |i|
             r << ScanLine.new(self,i)
           end
+          r.delete_if(&:bad?)
           r
         end
     end
 
     def to_s h={}
-      scanlines.map{ |l| l.to_s(h) }.join("\n")
+      if scanlines.any?
+        scanlines.map{ |l| l.to_s(h) }.join("\n")
+      else
+        super()
+      end
     end
 
     def extract_block x,y=nil,w=nil,h=nil
@@ -118,14 +180,55 @@ module ZPNG
     def export
       imagedata # fill @imagedata, if not already filled
 
-      # delete redundant IDAT chunks
-      first_idat = @chunks.find{ |c| c.type == 'IDAT' }
-      @chunks.delete_if{ |c| c.type == 'IDAT' && c != first_idat }
+      # delete old IDAT chunks
+      @chunks.delete_if{ |c| c.is_a?(Chunk::IDAT) }
 
       # fill first_idat @data with compressed imagedata
-      first_idat.data = Zlib::Deflate.deflate(scanlines.map(&:export).join, 9)
+      @chunks << Chunk::IDAT.new(
+        :data => Zlib::Deflate.deflate(scanlines.map(&:export).join, 9)
+      )
+
+      # delete IEND chunk(s) b/c we just added a new chunk and IEND must be the last one
+      @chunks.delete_if{ |c| c.is_a?(Chunk::IEND) }
+
+      # add fresh new IEND
+      @chunks << Chunk::IEND.new
 
       PNG_HDR + @chunks.map(&:export).join
     end
+
+    # modifies this image
+    def crop! params
+      decode_all_scanlines
+
+      x,y,h,w = (params[:x]||0), (params[:y]||0), params[:height], params[:width]
+      raise "negative params not allowed" if [x,y,h,w].any?{ |x| x < 0 }
+
+      # adjust crop sizes if they greater than image sizes
+      h = self.height-y if (y+h) > self.height
+      w = self.width-x if (x+w) > self.width
+      raise "negative params not allowed (p2)" if [x,y,h,w].any?{ |x| x < 0 }
+
+      # delete excess scanlines at tail
+      scanlines[(y+h)..-1] = [] if (y+h) < scanlines.size
+
+      # delete excess scanlines at head
+      scanlines[0,y] = [] if y > 0
+
+      # crop remaining scanlines
+      scanlines.each{ |l| l.crop!(x,w) }
+
+      # modify header
+      hdr.height, hdr.width = h, w
+
+      # return self
+      self
+    end
+
+    # returns new image
+    def crop params
+      # deep copy first, then crop!
+      Marshal.load(Marshal.dump(self)).crop!(params)
+    end
   end
 end

data/lib/zpng/scan_line.rb

@@ -1,3 +1,4 @@
+#coding: binary
 module ZPNG
   class ScanLine
     FILTER_NONE           = 0
@@ -12,17 +13,41 @@ module ZPNG
       @image,@idx = image,idx
       @bpp = image.hdr.bpp
       raise "[!] zero bpp" if @bpp == 0
-      if @BPP = (@bpp%8 == 0) && (@bpp>>3)
-        @offset = idx*(image.width*@BPP+1)
+
+      # Bytes Per Pixel, if bpp = 8, 16, 24, 32
+      # NULL otherwise
+      @BPP = (@bpp%8 == 0) && (@bpp>>3)
+
+      if @image.new?
+        @decoded_bytes = "\x00" * (size-1)
+        @filter = FILTER_NONE
       else
-        @offset = idx*(image.width*@bpp/8.0+1).ceil
+        @offset = idx*size
+        if @filter = image.imagedata[@offset]
+          @filter = @filter.ord
+        else
+          STDERR.puts "[!] #{self.class}: ##@idx: no data at pos 0, scanline dropped".red
+        end
+        @offset += 1
+      end
+    end
+
+    # ScanLine is BAD if it has no filter
+    def bad?
+      !@filter
+    end
+
+    # total scanline size in bytes, INCLUDING leading 'filter' byte
+    def size
+      if @BPP
+        image.width*@BPP+1
+      else
+        (image.width*@bpp/8.0+1).ceil
       end
-      @filter = image.imagedata[@offset].ord
-      @offset += 1
     end
 
     def inspect
-      "#<ZPNG::ScanLine " + (instance_variables-[:@image, :@decoded]).
+      "#<ZPNG::ScanLine " + (instance_variables-[:@image, :@decoded, :@BPP]).
           map{ |var| "#{var.to_s.tr('@','')}=#{instance_variable_get(var)}" }.
           join(", ") + ">"
     end
@@ -34,6 +59,7 @@ module ZPNG
 
       @image.width.times.map do |i|
         px = decode_pixel(i)
+#        printf "[d] %08x %s %s\n", px.to_i, px.inspect, px.to_s unless px.black?
         px.white?? white : (px.black?? black : unknown)
       end.join
     end
@@ -43,40 +69,37 @@ module ZPNG
     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
+
       case @bpp
-      when 1
-        flag =
-          if image.hdr.palette_used?
-            idx = image.palette.index(newcolor)
-            raise "no color #{newcolor.inspect} in palette" unless idx
-            idx == 1
-          else
-            if newcolor.white?
-              true
-            elsif newcolor.black?
-              false
-            else
-              raise "1bpp pixel can only be WHITE or BLACK, got #{newcolor.inspect}"
-            end
-          end
-        if flag
-          # turn pixel on
-          decoded_bytes[x/8] = (decoded_bytes[x/8].ord | (1<<(7-(x%8)))).chr
-        else
-          # turn pixel off
-          decoded_bytes[x/8] = (decoded_bytes[x/8].ord & (0xff-(1<<(7-(x%8))))).chr
-        end
+      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
+
+        b = (b & (0xff-(mask<<shift))) | ((color_idx & mask) << shift)
+        decoded_bytes[pos] = b.chr
+
       when 8
         if image.hdr.palette_used?
-          decoded_bytes[x] = (image.palette.index(newcolor)).chr
+          decoded_bytes[x] = color_idx.chr
         else
           decoded_bytes[x] = ((newcolor.r + newcolor.g + newcolor.b)/3).chr
         end
       when 16
         if image.hdr.palette_used? && image.hdr.alpha_used?
-          decoded_bytes[x*2] = (image.palette.index(newcolor)).chr
+          decoded_bytes[x*2] = color_idx.chr
           decoded_bytes[x*2+1] = (newcolor.alpha || 0xff).chr
-        elsif image.hdr.grayscale? && image.hdr.alpha_used?
+        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
@@ -97,56 +120,51 @@ module ZPNG
           decoded_bytes[x*@BPP, @BPP]
         else
           # 1, 2 or 4 bits per pixel
-          decoded_bytes[x*@bpp/8, (@bpp/8.0).ceil]
+          decoded_bytes[x*@bpp/8]
         end
 
-      r = g = b = a = nil
-
-      colormode = image.hdr.color
-
-      if image.hdr.palette_used?
-        idx =
-          case @bpp
-          when 1
-            # needed for palette
-            (raw.ord & (1<<(7-(x%8)))) == 0 ? 0 : 1
-          when 8
-            raw.ord
-          when 16
-            raw[0].ord
-          else raise "unexpected bpp #{@bpp}"
-          end
-
-        return image.palette[idx]
-      end
-
-      case @bpp
-      when 1
-        r=g=b= (raw.ord & (1<<(7-(x%8)))) == 0 ? 0 : 0xff
-      when 8
-        if colormode == ZPNG::Chunk::IHDR::COLOR_GRAYSCALE
-          r=g=b= raw.ord
+      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
+          raw.unpack 'C2'
+        when 24
+          # RGB
+          return Color.new(*raw.unpack('C3'))
+        when 32
+          # RGBA
+          return Color.new(*raw.unpack('C4'))
         else
-          raise "unexpected colormode #{colormode} for bpp #{@bpp}"
+          raise "unexpected bpp #{@bpp}"
         end
-      when 16
-        if colormode == ZPNG::Chunk::IHDR::COLOR_GRAY_ALPHA
-          r=g=b= raw[0].ord
-          a = raw[1].ord
-        else
-          raise "unexpected colormode #{colormode} for bpp #{@bpp}"
+
+      if image.grayscale?
+        if [1,2,4].include?(@bpp)
+          #color should be extended to a 8-bit range
+          if color%2 == 0
+            color <<= (8-@bpp)
+          else
+            (8-@bpp).times{ color = color*2 + 1 }
+          end
         end
-      when 24
-        r,g,b = raw.split('').map(&:ord)
-      when 32
-        r,g,b,a = raw.split('').map(&:ord)
-      else raise "unexpected bpp #{@bpp}"
+        Color.from_grayscale(color, alpha)
+      elsif image.palette
+        color = image.palette[color]
+        color.alpha = alpha
+        color
+      else
+        raise "cannot decode color"
       end
-
-      Color.new(r,g,b,a)
     end
 
     def decoded_bytes
+      raise if caller.size > 50
       @decoded_bytes ||=
         begin
           # number of bytes per complete pixel, rounding up to one
@@ -170,11 +188,12 @@ module ZPNG
       true
     end
 
+    private
     def decode_byte x, b0, bpp1
       raw = @image.imagedata[@offset+x]
 
       unless raw
-        STDERR.puts "[!] not enough bytes at pos #{x} of scanline #@idx".red
+        STDERR.puts "[!] #{self.class}: ##@idx: no data at pos #{x}".red
         raw = 0.chr
       end
 
@@ -214,9 +233,54 @@ module ZPNG
       (pa <= pb) ? (pa <= pc ? a : c) : (pb <= pc ? b : c)
     end
 
+    public
+    def crop! x, w
+      if @BPP
+        # great, crop is byte-aligned! :)
+        decoded_bytes[0,x*@BPP]   = ''
+        decoded_bytes[w*@BPP..-1] = ''
+      else
+        # oh, no we have to shift bits in a whole line :(
+        case @bpp
+        when 1,2,4
+          cut_bits_head = @bpp*x
+          if cut_bits_head > 8
+            # cut whole head bytes
+            decoded_bytes[0,cut_bits_head/8] = ''
+          end
+          cut_bits_head %= 8
+          if cut_bits_head > 0
+            # bit-shift all remaining bytes
+            (w*@bpp/8.0).ceil.times do |i|
+              decoded_bytes[i] = ((
+                (decoded_bytes[i].ord<<cut_bits_head) |
+                (decoded_bytes[i+1].ord>>(8-cut_bits_head))
+              ) & 0xff).chr
+            end
+          end
+
+          new_width_bits = w*@bpp
+          diff = decoded_bytes.size*8 - new_width_bits
+          raise if diff < 0
+          if diff > 8
+            # cut whole tail bytes
+            decoded_bytes[(new_width_bits/8.0).ceil..-1] = ''
+          end
+          diff %= 8
+          if diff > 0
+            # zero tail bits of last byte
+            decoded_bytes[-1] = (decoded_bytes[-1].ord & (0xff-(2**diff)+1)).chr
+          end
+
+        else
+          raise "unexpected bpp=#@bpp"
+        end
+      end
+    end
+
     def export
       # we export in FILTER_NONE mode
-      "\x00" + decoded_bytes
+      FILTER_NONE.chr + decoded_bytes
     end
   end
 end