sugar_png 0.0.1 → 0.5.2

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

data/spec/color_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe SugarPNG::Color do
+  it "creates color from string" do
+    SugarPNG::Color.new('blue').should == SugarPNG::Color::BLUE
+    SugarPNG::Color.new('Blue').should == SugarPNG::Color::BLUE
+    SugarPNG::Color.new('BLUE').should == SugarPNG::Color::BLUE
+  end
+  it "creates color from symbol" do
+    SugarPNG::Color.new(:blue).should == SugarPNG::Color::BLUE
+    SugarPNG::Color.new(:blue, :depth => 16).should == SugarPNG::Color::BLUE.to_depth(16)
+  end
+  it "creates color from hex" do
+    SugarPNG::Color.new(0x0000ff).should == SugarPNG::Color::BLUE
+    SugarPNG::Color.new(0x00f, :depth => 4).should == SugarPNG::Color::BLUE.to_depth(4)
+  end
+  it "creates color from html" do
+    SugarPNG::Color.new("#0000ff").should == SugarPNG::Color::BLUE
+    SugarPNG::Color.new("#00f").should == SugarPNG::Color::BLUE
+  end
+  it "creates color from r,g,b" do
+    SugarPNG::Color.new(0,0,255).should == SugarPNG::Color::BLUE
+  end
+  it "creates color from long hash" do
+    SugarPNG::Color.new(:red => 0, :green => 0, :blue => 0xff).should == SugarPNG::Color::BLUE
+  end
+  it "creates color from short hash" do
+    SugarPNG::Color.new(:r => 0, :g => 0, :b => 0xff).should == SugarPNG::Color::BLUE
+  end
+
+  it "raises exception on invalid number of params" do
+    lambda{
+      SugarPNG::Color.new(1,2,3,4,5,6)
+    }.should raise_error(SugarPNG::ArgumentError)
+  end
+
+  it "raises exception on invalid number of params" do
+    lambda{
+      SugarPNG::Color.new(1,2)
+    }.should raise_error(SugarPNG::ArgumentError)
+  end
+
+  it "raises exception on invalid key" do
+    lambda{
+      SugarPNG::Color.new( :foo => :bar )
+    }.should raise_error(SugarPNG::ArgumentError)
+  end
+
+  it "raises exception on invalid HTML color" do
+    lambda{ SugarPNG::Color.new( "#12" ) }.should raise_error(SugarPNG::ArgumentError)
+    lambda{ SugarPNG::Color.new( "#1234" ) }.should raise_error(SugarPNG::ArgumentError)
+  end
+
+  it "raises exception on invalid color name" do
+    lambda{ SugarPNG::Color.new( "bzzz" ) }.should raise_error(SugarPNG::ArgumentError)
+  end
+
+  it "raises exception on invalid depth" do
+    expect{ SugarPNG::Color.new( :depth => 0 ) }.to raise_error(SugarPNG::ArgumentError)
+  end
+  it "raises exception on invalid depth" do
+    expect{ SugarPNG::Color.new( :depth => -1 ) }.to raise_error(SugarPNG::ArgumentError)
+  end
+  it "raises exception on invalid depth" do
+    expect{ SugarPNG::Color.new( :depth => 17 ) }.to raise_error(SugarPNG::ArgumentError)
+  end
+  it "raises exception on invalid depth" do
+    expect{ SugarPNG::Color.new( :depth => "foo" ) }.to raise_error(SugarPNG::ArgumentError)
+  end
+
+  it "raises exception on invalid channel value" do
+    expect{ SugarPNG::Color.new( :red => 1000 ) }.to raise_error(SugarPNG::ArgumentError)
+    expect{ SugarPNG::Color.new( :red => -1 ) }.to raise_error(SugarPNG::ArgumentError)
+  end
+
+  it "raises exception on invalid argument type" do
+    expect{ SugarPNG::Color.new( 1.25  ) }.to raise_error(SugarPNG::ArgumentError)
+    expect{ SugarPNG::Color.new( false ) }.to raise_error(SugarPNG::ArgumentError)
+    expect{ SugarPNG::Color.new( true  ) }.to raise_error(SugarPNG::ArgumentError)
+  end
+end

data/spec/font_spec.rb

@@ -0,0 +1,82 @@
+#coding: utf-8
+require 'spec_helper'
+
+describe SugarPNG::Font do
+  subject(:font){ SugarPNG::Font.new }
+
+  it "should get 'R'" do
+    char = <<-EOF.strip.split("\n").map(&:strip).join("\n")
+       ........
+       ........
+       ........
+       ........
+       .#####..
+       .#....#.
+       .#....#.
+       .#....#.
+       .#####..
+       .#..#...
+       .#...#..
+       .#...#..
+       .#....#.
+       .#....#.
+       ........
+       ........
+    EOF
+    font['R'].to_s(".#").should == char
+  end
+
+  it "should get '水'" do
+    char = <<-EOF.strip.split("\n").map(&:strip).join("\n")
+       .......#........
+       .......#........
+       .......#........
+       .......#....#...
+       .......#....#...
+       .#####.##..#....
+       .....#.##.#.....
+       ....#..#.#......
+       ....#..#.#......
+       ...#...#..#.....
+       ...#...#...#....
+       ..#....#....#...
+       .#.....#.....##.
+       #......#........
+       .....#.#........
+       ......#.........
+    EOF
+    font['水'].to_s(".#").should == char
+    font['水'].width.should == 16
+    font['水'].ord.should == '水'.ord
+  end
+
+  it "should get identical glyphs from int/string" do
+    font['A'].should == font['A'.ord]
+  end
+
+  %w'A Z 0 Ж'.each do |char|
+    describe "glyph '#{char}'" do
+      subject(:glyph){ font[char] }
+
+      it { should_not be_nil   }
+      it { should_not be_blank }
+
+      its(:width) { should == 8 }
+      its(:height){ should == 16 }
+      its(:data)  { should_not be_empty }
+      its(:ord)   { should == char.ord }
+    end
+  end
+
+  describe "glyph ' ' (space)" do
+    subject(:glyph){ font[' '] }
+
+    it { should_not be_nil   }
+    it { should     be_blank }
+
+    its(:width) { should == 8 }
+    its(:height){ should == 16 }
+    its(:data)  { should_not be_empty }
+    its(:ord)   { should == ' '.ord }
+  end
+end