sugar_png 0.0.1 → 0.4.0

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

data/lib/sugar_png/datastream.rb

@@ -1,19 +1,4 @@
-module SugarPNG
-  class Datastream
-    attr_accessor :img
-
-    def initialize h={}
-      @img = h[:img]
-    end
-
-    def metadata
-      {}
-    end
-
-    class << self
-      def from_file fname
-        self.new :img => ZPNG::Image.load(fname)
-      end
-    end
+class SugarPNG
+  class Datastream < ZPNG::Image
   end
 end

data/lib/sugar_png/dyn_accessor.rb

@@ -0,0 +1,28 @@
+class SugarPNG
+  module DynAccessor
+    def dyn_accessor *names
+      names.each do |name|
+        if name.is_a?(Hash)
+          # dynamic accessor with alias(es)
+          name.each do |main, aliases|
+            dyn_accessor main
+            Array(aliases).each do |aliased|
+              class_eval <<-EOF
+                alias :#{aliased}  :#{main}
+                alias :#{aliased}= :#{main}=
+              EOF
+            end
+          end
+        else
+          attr_writer name
+          # dynamic getter or setter based on argument given or not
+          class_eval <<-EOF
+            def #{name} arg=nil
+              arg ? @#{name} = arg : @#{name}
+            end
+          EOF
+        end
+      end
+    end
+  end
+end

data/lib/sugar_png/font.rb

@@ -0,0 +1,44 @@
+class SugarPNG
+  class Font
+    DEFAULT_DIR = File.expand_path("../../data/font", File.dirname(__FILE__))
+    HEIGHT = 16
+
+    def initialize dir = DEFAULT_DIR
+      @dir   = dir
+      @pages = {}
+    end
+
+    def height
+      HEIGHT
+    end
+
+    # get glyph by index
+    def [] idx
+      idx = idx.ord if !idx.is_a?(Integer) && idx.respond_to?(:ord)
+      raise ArgumentError.new("invalid idx type: #{idx.class}") unless idx.is_a?(Integer)
+      raise ArgumentError.new("invalid idx: #{idx.inspect}") if idx<0 || idx>0xffff
+
+      pageno = idx >> 8
+      @pages[pageno] ||= Page.new(File.join(@dir, "%02x" % pageno))
+      @pages[pageno][idx]
+    end
+
+    class Page
+      def initialize fname
+        @data   = Marshal.load(File.binread(fname))
+        @glyphs = {}
+      end
+
+      # get glyph by index
+      def [] ord
+        idx = ord&0xff
+        @glyphs[idx] ||= Glyph.new(
+          :height => HEIGHT,
+          :width  => @data[idx].size/2,
+          :data   => @data[idx],
+          :ord    => ord
+        )
+      end
+    end # class Page
+  end # class Font
+end

data/lib/sugar_png/glyph.rb

@@ -0,0 +1,36 @@
+class SugarPNG
+  class Glyph
+    attr_accessor :width, :height, :data, :ord
+
+    def initialize h = {}
+      @ord    = h[:ord]
+      @data   = h[:data]
+      @width  = h[:width]
+      @height = h[:height]
+    end
+
+    def blank?
+      @data.tr("\x00","").empty?
+    end
+
+    def to_s repl=" #"
+      bytes_in_row = (@width/8.0).ceil
+      r = ''; ptr = 0
+      @height.times.each do
+        r += @data[ptr,bytes_in_row].unpack("B#@width")[0].tr("01",repl) + "\n"
+        ptr += bytes_in_row
+      end
+      r.chomp
+    end
+
+    def to_a
+      bytes_in_row = (@width/8.0).ceil
+      r = []; ptr = 0
+      @height.times.each do
+        r << @data[ptr,bytes_in_row].unpack("B#@width")[0].split('').map(&:to_i)
+        ptr += bytes_in_row
+      end
+      r
+    end
+  end
+end

data/lib/sugar_png/image.rb

@@ -0,0 +1,104 @@
+class SugarPNG
+  class Image < ZPNG::Image
+    def to_rgba_stream
+      pixels.map do |color|
+        color.to_depth(8).to_a.pack('C*')
+      end.join
+    end
+
+    def clear color
+      width.times do |x|
+        self[x,0] = color
+      end
+      sl0 = scanlines[0]
+      scanlines[1..-1].each do |sl|
+        sl.decoded_bytes = sl0.decoded_bytes.dup
+      end
+    end
+
+    def draw_borders borders
+      xmin = 0
+      xmax = self.width - 1
+      ytop = 0
+      ybtm = self.height - 1
+
+      sumtop = borders.map(&:top).inject(&:+)
+      sumbtm = borders.map(&:bottom).inject(&:+)
+
+      borders.each do |b|
+        b.top.times do
+          xmin.upto(xmax){ |x| self[x,ytop] = b.color }
+          ytop += 1
+        end
+        b.bottom.times do
+          xmin.upto(xmax){ |x| self[x,ybtm] = b.color }
+          ybtm -= 1
+        end
+        b.left.times do
+          ytop.upto(sumtop){ |y| self[xmin, y] = b.color }
+          ybtm.downto(height-sumbtm){ |y| self[xmin, y] = b.color }
+          xmin += 1
+        end
+        b.right.times do
+          ytop.upto(sumtop){ |y| self[xmax, y] = b.color }
+          ybtm.downto(height-sumbtm){ |y| self[xmax, y] = b.color }
+          xmax -= 1
+        end
+      end
+
+      # copy remaining identical scanlines
+      sl0 = scanlines[ytop]
+      (ytop+1).upto(ybtm) do |y|
+        scanlines[y].decoded_bytes = sl0.decoded_bytes.dup
+      end
+    end # draw_borders
+
+    # zooms image by specified *integer* factor,
+    # returns self if zoom == 1, new image if zoom > 1
+    def zoom factor
+      factor = factor.to_i
+      return self if factor == 1 # no zoom required
+      raise ArgumentError.new("Invalid zoom factor #{factor}") if factor < 1
+
+      new_img = Image.new(
+        :width  => self.width*factor,
+        :height => self.height*factor,
+        :color  => self.hdr.color,
+        :depth  => self.hdr.depth
+      )
+
+      if self.bpp % 8 == 0
+        nbytes = self.bpp / 8
+        # fast-zoom is possible
+        scanlines.each_with_index do |sl,idx|
+          new_sl = new_img.scanlines[idx*factor]
+          self.width.times do |x|
+            new_sl.decoded_bytes[x*factor*nbytes, factor*nbytes] =
+              sl.decoded_bytes[x*nbytes,nbytes]*factor
+          end
+          # copy scanlines
+          (factor-1).times do |i|
+            new_img.scanlines[idx*factor+i+1].decoded_bytes = new_sl.decoded_bytes
+          end
+        end
+      else
+        # slow-zoom
+        scanlines.each_with_index do |sl,idx|
+          new_sl = new_img.scanlines[idx*factor]
+          self.width.times do |x|
+            c = sl[x]
+            factor.times do |zx|
+              new_sl[x*factor + zx] = c
+            end
+          end
+          # copy scanlines
+          (factor-1).times do |i|
+            new_img.scanlines[idx*factor+i+1].decoded_bytes = new_sl.decoded_bytes
+          end
+        end
+      end
+
+      new_img
+    end
+  end
+end