sugar_png 0.0.1 → 0.5.2

data/data/unused-4-read-tar.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+#   struct tarfile_entry_posix
+#   {                      //                               pack/unpack
+#      char name[100];     // ASCII (+ Z unless filled)     a100/Z100
+#      char mode[8];       // 0 padded, octal, null         a8  /A8
+#      char uid[8];        // ditto                         a8  /A8
+#      char gid[8];        // ditto                         a8  /A8
+#      char size[12];      // 0 padded, octal, null         a12 /A12
+#      char mtime[12];     // 0 padded, octal, null         a12 /A12
+#      char checksum[8];   // 0 padded, octal, null, space  a8  /A8
+#      char typeflag[1];   // see below                     a   /a
+#      char linkname[100]; // ASCII + (Z unless filled)     a100/Z100
+#      char magic[6];      // "ustar\0"                     a6  /A6
+#      char version[2];    // "00"                          a2  /A2
+#      char uname[32];     // ASCIIZ                        a32 /Z32
+#      char gname[32];     // ASCIIZ                        a32 /Z32
+#      char devmajor[8];   // 0 padded, octal, null         a8  /A8
+#      char devminor[8];   // 0 padded, octal, null         a8  /A8
+#      char prefix[155];   // ASCII (+ Z unless filled)     a155/Z155
+#   };
+
+HEADER_UNPACK_FORMAT  = "Z100x24A12"
+
+File.open("data.tar","rb") do |f|
+  while true
+    data = f.read 136 # 100+8+8+8+12 - we don't want all the fields from header
+    name,size = data.unpack(HEADER_UNPACK_FORMAT)
+
+    # "end of archive is marked by at least 2 consecutive zero-filled records"
+    # - but I make it simpler b/c I generate archive myself and guarantee that
+    #   EOF is one empty entry // ZZZ
+    break if name.empty?
+    size = size.to_i(8)
+
+    printf "[.] %04x: ", f.tell+376
+    p [name,size]
+
+    # The file data is written unaltered except that its length is rounded up
+    # to a multiple of 512 bytes and the extra space is filled with zero bytes.
+    if size & 0x1ff != 0
+      size = (size | 0x1ff) + 1
+    end
+
+
+    # 376 = 512-136 - compensate for skipped header bytes
+    f.seek size+376, IO::SEEK_CUR
+  end
+end

data/lib/sugar_png.rb

@@ -1,5 +1,167 @@
 require 'zpng'
 
-SugarPNG = ZPNG
+require 'sugar_png/dyn_accessor'
+require 'sugar_png/color'
+require 'sugar_png/border'
+require 'sugar_png/image'
+require 'sugar_png/font'
+require 'sugar_png/glyph'
 
-require 'sugar_png/datastream'
+class SugarPNG
+  DEFAULT_BG = :transparent
+  DEFAULT_FG = :black
+
+  Canvas = Datastream = Image
+
+  class Exception < ::Exception; end
+  class ArgumentError < Exception; end
+
+  extend DynAccessor
+  dyn_accessor :width, :height, :zoom, :depth
+  dyn_accessor :bg => %w'background bg_color background_color'
+  dyn_accessor :fg => %w'foreground fg_color foreground_color color'
+
+  def initialize h={}, &block
+    @bg   = DEFAULT_BG
+    @fg   = DEFAULT_FG
+    @zoom = 1
+    clear
+
+    if block_given?
+      if block.arity == 1
+        yield self
+      else
+        instance_eval &block
+      end
+    end
+
+    # boring non-magic hash
+    h.each do |k,v|
+      self.send "#{k}=", v
+    end
+  end
+
+  # reset all drawings
+  def clear
+    @pixels  = Hash.new{ |k,v| k[v] = {} }
+    @borders = []
+  end
+
+  # set pixels
+  # accepted coordinate values:
+  # a) boring Integers
+  # b) neat   Arrays
+  # c) long   Ranges
+  # d) super  Enumerators
+  #
+  # accepted color values: see SugarPNG::Color
+  def []= ax, ay, color
+    Array(ay).each do |y|
+      Array(ax).each do |x|
+        @pixels[y][x] = color
+      end
+    end
+  end
+
+  # same as above, but color argument can be optional
+  def pixel ax, ay, color = @fg
+    Array(ay).each do |y|
+      Array(ax).each do |x|
+        @pixels[y][x] = color
+      end
+    end
+  end
+  alias :pixels :pixel
+
+  %w'put_pixel set_pixel point dot'.each do |x|
+    # plural & singular aliases to increase entropy & prevent global singularity
+    class_eval "alias :#{x} :pixel; alias :#{x}s :pixels"
+  end
+
+  # draw image border with specified color
+  def border size, color = nil
+    color ||= @fg || @bg
+    @borders << Border.new( size.is_a?(Hash) ? size : {:size => size, :color => color} )
+  end
+
+  # same as border, but default color is background
+  def padding size, color = @bg
+    border size, color
+  end
+
+  # draw a single glyph, used from within text()
+  def draw_glyph glyph, x0, y, color
+    #TODO: optimize?
+    glyph.to_a.each do |row|
+      x = x0
+      row.each do |bit|
+        self[x,y] = color if bit == 1
+        x += 1
+      end
+      y += 1
+    end
+  end
+
+  # draws text, optional arguments are :color, :x, :y
+  def text text, h = {}
+    font  = @font ||= Font.new
+    color = h[:color] || @fg
+    y = h[:y] || 0
+    text.split(/[\r\n]+/).each do |line|
+      x = h[:x] || 0
+      line.each_char do |c|
+        glyph = font[c]
+        draw_glyph glyph, x, y, color
+        x += glyph.width
+      end
+      y += font.height
+    end
+  end
+
+  # export PNG to file
+  def save fname
+    File.open(fname, "wb"){ |f| f<<to_s }
+  end
+
+  # get PNG as bytestream, for saving it to file manually, or for sending via HTTP
+  def to_s
+    height = @height || ((t=@pixels.keys.max) && t+1 ) || 0
+    width = @width || ((t=@pixels.values.map(&:keys).map(&:max).max) && t+1 ) || 0
+
+    xofs = yofs = 0
+    xmax = width-1
+    ymax = height-1
+
+    if @borders.any?
+      width  += @borders.map(&:width).inject(&:+)
+      height += @borders.map(&:height).inject(&:+)
+      xofs   += @borders.map(&:left).inject(&:+)
+      yofs   += @borders.map(&:top).inject(&:+)
+    end
+
+    raise(Exception.new("invalid image height #{height}")) if height <= 0
+    raise(Exception.new("invalid image width #{width}")) if width <= 0
+
+    img = Image.new :width => width, :height => height, :depth => @depth
+    img.clear(_color(@bg))     if @bg
+    img.draw_borders(@borders.each{ |b| b.color = _color(b.color)} )
+
+    @pixels.each do |y, xh|
+      next if y>ymax
+      xh.each do |x, c|
+        next if x>xmax
+        img[x+xofs,y+yofs] = _color(c)
+      end
+    end
+
+    img.zoom(@zoom).export
+  end
+  alias :export :to_s
+
+  private
+
+  # create color from any of the supported color representations
+  def _color c
+    c = c.is_a?(ZPNG::Color) ? c : Color.new(c, :depth => @depth)
+  end
+end

data/lib/sugar_png/border.rb

@@ -0,0 +1,20 @@
+class SugarPNG
+  class Border
+    attr_accessor :left, :right, :top, :bottom, :color
+    def initialize h
+      @color = h[:color] || raise(ArgumentError.new("border color must be set"))
+      @left  = (h[:left]  || h[:size]).to_i
+      @right = (h[:right] || h[:size]).to_i
+      @top   = (h[:top]   || h[:size]).to_i
+      @bottom= (h[:bottom]|| h[:size]).to_i
+    end
+
+    def width
+      @left + @right
+    end
+
+    def height
+      @top + @bottom
+    end
+  end
+end

data/lib/sugar_png/color.rb

@@ -0,0 +1,118 @@
+class SugarPNG
+  class Color < ZPNG::Color
+    class << self
+      def a color
+        color.a || (2**color.depth-1)
+      end
+
+      def r color; color.r; end
+      def g color; color.g; end
+      def b color; color.b; end
+    end
+
+    # accepted color values:
+    # a) Strings:       "blue", "RED", ...
+    # b) Symbols:       :blue, :red, ...
+    # c) HTML notation: #cc3344, #ccc, ...
+    # d) 3..4 int args: (10, 20, 30) - RGB; (0x20,0x30,0x40,0xff) - RGBA
+    # e) Hexadecimals   0xaabbcc - RGB; 0x80aabbcc - RGBA
+    # f) Hashes (long): { :red => 10, :green => 30, :blue => 40, :alpha => 0x80 }
+    # g) Hashes (shrt): { r:10, g:20, b:30, a:50 } (alpha is optional)
+    #
+    # all notations also accept one optional last argument - hash:
+    #   :depth => 1..16       - color depth of each channel, including alpha
+    #   :alpha => 0..2^depth  - explicit definition of alpha value
+    def initialize *args
+      h = args.last.is_a?(Hash) ? args.pop : {}
+
+      @depth = h.delete(:depth) || 8
+      raise ArgumentError.new "invalid depth: #@depth" unless (1..16).include?(@depth)
+
+      max = 2**@depth-1
+
+      case args.size
+      when 0        # single Hash that already in h
+        # init colors to default values, we'll assign them later
+        @r = @g = @b = 0
+      when 1        # String(name or html), Symbol, Array, Integer, Hash
+        case arg = args.first
+        when String
+          _from_string(arg)
+
+        when Symbol
+          _from_string(arg.to_s)
+
+        when Array
+          case arg.size
+          when 3
+            @r,@g,@b = arg
+          when 4
+            @r,@g,@b,@a = arg
+          else
+            raise ArgumentError.new "invalid array size: #{arg.size}, must be 3 or 4"
+          end
+        when Integer
+          @r = (arg >> (@depth*2)) & max
+          @g = (arg >> (@depth)) & max
+          @b = arg & max
+        when Hash
+          # init colors to default values, we'll assign them later
+          @r = @g = @b = 0
+          h.merge! args.first
+        else
+          raise ArgumentError.new "invalid argument type: #{args.first.class}"
+        end
+      when 3        # r, g, b
+        @r, @g, @b = args
+      when 4        # r, g, b, a
+        @r, @g, @b, @a = args
+      else
+        raise ArgumentError.new "invalid number of arguments: #{args.size}"
+      end
+
+      @a ||= max  # opaque by default
+
+      h.each do |k,v|
+        case k
+        when :r, :red
+          @r = v
+        when :g, :green
+          @g = v
+        when :b, :blue
+          @b = v
+        when :a, :alpha
+          @a = v
+        else
+          raise ArgumentError.new "invalid key: #{k}"
+        end
+      end
+
+      [:r, :g, :b, :a].each do |x|
+        v = self.send(x).to_i
+        raise ArgumentError.new "invalid channel value: #{v}" if v<0 || v>max
+      end
+    end
+
+    private
+
+    # initialize self from string, either HTML color or simple color name
+    # @depth must already be set!
+    def _from_string s
+      if s[0,1] == "#"
+        # html colors #aabbcc or #abc
+        case s.size
+        when 4
+          @r,@g,@b = s[1..-1].split('').map{ |x| x.to_i(16)*17 }
+        when 7
+          @r,@g,@b = s[1..-1].scan(/../).map{ |x| x.to_i(16) }
+        else
+          raise ArgumentError.new "invalid HTML color #{s}"
+        end
+      else
+        @r, @g, @b, @a = self.class.const_get(s.strip.upcase).to_depth(@depth).to_a
+      end
+    rescue
+      raise ArgumentError.new "invalid color name: #{s}"
+    end
+  end
+end