CooCoo 0.1.0

data/lib/coo-coo/drawing/canvas.rb

@@ -0,0 +1,68 @@
+require 'chunky_png'
+require 'coo-coo/math'
+
+module CooCoo
+  module Drawing
+    class Canvas
+      attr_accessor :fill_color, :stroke_color
+
+      def fill_color=(c)
+        @fill_color = ChunkyPNG::Color.parse(c)
+      end
+
+      def stroke_color=(c)
+        @stroke_color = ChunkyPNG::Color.parse(c)
+      end
+
+      def flush
+        self
+      end
+      
+      def line(x1, y1, x2, y2)
+        self
+      end
+
+      def stroke(points)
+        self
+      end
+
+      def rect(x, y, w, h)
+        self
+      end
+
+      def circle(x, y, r)
+        self
+      end
+
+      def blit(img, x, y)
+        self
+      end
+
+      def text(txt, x, y, font, size, style = nil)
+        self
+      end
+
+      protected
+      def color_components(c)
+        [ ChunkyPNG::Color.r(c),
+          ChunkyPNG::Color.g(c),
+          ChunkyPNG::Color.b(c)
+        ]
+      end
+
+      def to_grayscale(c)
+        ChunkyPNG::Color.r(ChunkyPNG::Color.to_grayscale(c))
+      end
+      
+      def chunky_to_vector(img, grayscale)
+        f = if grayscale
+              method(:to_grayscale)
+            else
+              method(:color_components)
+            end
+        
+        Vector[img.pixels.collect(&f).flatten]
+      end
+    end
+  end
+end

data/lib/coo-coo/drawing/chunky_canvas.rb

@@ -0,0 +1,101 @@
+require 'chunky_png'
+require 'coo-coo/math'
+
+module CooCoo
+  module Drawing
+    class ChunkyCanvas < Canvas
+      attr_reader :image
+      
+      def initialize(img_or_width, height = nil)
+        if height
+          img = ChunkyPNG::Image.new(img_or_width, height)
+        else
+          img = img_or_width
+        end
+        
+        @image = img
+      end
+
+      def line(x1, y1, x2, y2)
+        @image.line(x1, y1, x2, y2, stroke_color)
+        self
+      end
+
+      def stroke(points)
+        last_x = points[0][0]
+        last_y = points[0][1]
+        last_w = points[0][2] || 1.0
+        last_color = points[0][3]
+
+        points.each.drop(1).each do |(x, y, w, color)|
+          w ||= 1.0
+          
+          if color
+            self.stroke_color = color
+            self.fill_color = color
+          end
+          
+          if w <= 1.0
+            line(last_x.to_i, last_y.to_i, x.to_i, y.to_i)
+          else
+            step_x = (x / w).abs.round
+            step_y = (y / w).abs.round
+            steps = Math.max(step_x, step_y)
+            steps = 4.0 if steps < 4.0
+
+            (steps + 1).to_i.times do |n|
+              t = n / steps.to_f
+              if color
+                self.stroke_color = lerp_color(last_color, color, t)
+                self.fill_color = lerp_color(last_color, color, t)
+              end
+              
+              circle(Math.lerp(last_x, x, t).to_i,
+                     Math.lerp(last_y, y, t).to_i,
+                     (Math.lerp(last_w, w, t)/2.0).ceil.to_i)
+            end
+          end
+          
+          last_x = x
+          last_y = y
+          last_w = w
+          last_color = color
+        end
+
+        self
+      end
+
+      def lerp_color(a, b, t)
+        ChunkyPNG::Color.interpolate_quick(a, b, (t * 256).to_i)
+      end
+
+      def rect(x, y, w, h)
+        @image.rect(x, y, w, h, stroke_color, fill_color)
+        self
+      end
+
+      def circle(x, y, r)
+        @image.circle(x, y, r, stroke_color, fill_color)
+        self
+      end
+
+      def blit(other, x, y, w, h)
+        img = ChunkyPNG::Image.from_blob(other)
+        if w != img.width || h != img.height
+          img.resample_bilinear!(w.to_i, h.to_i)
+        end
+        @image.compose!(img, x.to_i, y.to_i)
+        self
+      end
+
+      def text(txt, x, y, font, font_size, font_style = nil)
+        self
+      end
+
+      def to_vector(grayscale = false)
+        chunky_to_vector(@image, grayscale)
+      end
+    end
+  end
+end
+  

data/lib/coo-coo/drawing/sixel.rb

@@ -0,0 +1,214 @@
+require 'stringio'
+
+module CooCoo
+  module Drawing
+    module Sixel
+      def self.from_array(a, width, height = nil)
+        s = Stringer.new
+        s.begin_sixel + s.from_array(a, width, height) + s.newline + s.finish_sixel
+      end
+
+      def self.with_sixel(io = $stdout, &block)
+        Streamer.new(io) do |s|
+          block.call(s)
+        end
+      end
+
+      def self.to_string(&block)
+        stream = StringIO.new
+        Streamer.new(stream, &block)
+        stream.string
+      end
+
+      class Streamer
+        def initialize(io = $stdout, stringer = Stringer.new, &block)
+          @io = io
+          @stringer = stringer
+          with_sixel(&block)
+        end
+
+        def method_missing(mid, *args, &block)
+          @io.write(@stringer.send(mid, *args, &block))
+        end
+
+        def with_sixel(&block)
+          begin_sixel
+          block.call(self)
+        ensure
+          finish_sixel
+        end
+      end
+      
+      class Stringer
+        RGB = Struct.new(:r, :g, :b)
+        HSL = Struct.new(:h, :s, :l)
+        
+        def initialize(options = Hash.new)
+          @max_colors = options.fetch(:max_colors, 256)
+          @colors = Array.new(@max_colors)
+          @background = options.fetch(:background, 0)
+        end
+        
+        def from_array(a, width, height = nil)
+          height ||= (a.size / width.to_f).ceil
+          max_color = a.max.ceil
+          
+          (height / 6.0).ceil.times.collect do |y|
+            (max_color + 1).times.collect do |c|
+              #next if c == 0
+              in_color(c) + width.times.collect do |x|
+                sixel_line(c, *6.times.collect { |i|
+                             a[(y*6+i) * width + x] rescue @background
+                           })
+              end.join
+            end.join(cr)
+          end.join(newline)
+        end
+
+        def sixel_line(c, *pixels)
+          line = 6.times.inject(0) { |acc, i|
+            if pixels[i].to_i == c
+              (acc | (1 << i))
+            else
+              acc
+            end
+          }
+          [ 63 + line ].pack('c')
+        end
+
+        def move_to(x, y)
+          finish_sixel + "\e[#{y.to_i};#{x.to_i}H" + begin_sixel
+        end
+        
+        def set_color(c, r, g, b)
+          @colors[c] = RGB.new(r, g, b)
+          emit_color(c)
+        end
+
+        def set_color_hsl(c, h, s, l)
+          @colors[c] = HSL.new(h, s, l)
+          emit_color(c)
+        end
+        
+        def emit_color(n, c = nil)
+          case c
+          when RGB then "\##{n.to_i};2;#{c.r.to_i};#{c.g.to_i};#{c.b.to_i}"
+          when HSL then "\##{n.to_i};1;#{c.h.to_i};#{c.s.to_i};#{c.l.to_i}"
+          else @colors[n] && emit_color(n, @colors[n])
+          end
+        end
+
+        def emit_all_colors
+          @colors.each.with_index.collect do |c, i|
+            emit_color(i, c) if c
+          end.join
+        end
+
+        def in_color(c)
+          "\##{c}"
+        end
+        
+        def start_sixel
+          "\ePq"
+        end
+
+        def begin_sixel
+          start_sixel + emit_all_colors
+        end
+
+        def finish_sixel
+          "\e\\"
+        end
+        
+        def cr
+          "$"
+        end
+
+        def lf
+          "-\n"
+        end
+
+        def newline
+          cr + lf
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  require 'coo-coo/math'
+  
+  HI = <<-EOT
+\ePq
+\#0;2;0;0;0\#1;2;100;0;0\#2;2;0;100;0
+\#1~~@@vv@@~~@@~~$
+\#2??}}GG}}??}}??-
+\#1!14@
+\e\\
+EOT
+
+  arr = 100.times.collect { |y|
+    100.times.collect { |x|
+      8 + (8 * (Math.cos(y / 100.0 * 6.28) * Math.sin(x / 100.0 * 6.28))).to_i
+    }
+  }.flatten
+  line = 100.times.collect { |y| 40.times.collect { |i| (i < 2 || i > 37) ? 15 : 0 } }.flatten
+  stringer = CooCoo::Drawing::Sixel::Stringer.new
+  
+  puts(HI)
+
+  puts
+  puts("In sixel")
+  puts(stringer.begin_sixel)
+  puts("\#0;2;100;0;0\#1;2;0;100;0\#2;2;0;0;100")
+  16.times {
+    $stdout.write(stringer.sixel_line(1, 1, 1, 0, 0, 1, 1))
+  }
+  puts
+  puts(stringer.sixel_line(1, 0, 0, 1, 1, 0, 0))
+  puts(stringer.sixel_line(1, 0, 0, 1, 1, 0, 0))
+  puts(stringer.sixel_line(2, 1, 1, 2, 2, 1, 1))
+  puts(stringer.sixel_line(2, 1, 1, 2, 2, 1, 1))
+  puts(stringer.sixel_line(1, 1, 1, 1, 1, 1, 1))
+  puts(stringer.sixel_line(1, 1, 1, 1, 1, 1, 1))
+  puts(stringer.sixel_line(1, 1, 1, 1, 1, 1, 1))
+  puts(stringer.finish_sixel)
+
+  puts("And the big one:")
+  puts
+  puts(stringer.begin_sixel)
+  #puts("\#0;2;100;0;0\#1;2;0;100;0\#2;2;0;0;100\#3;2;100,100,100")
+  16.times { |i| puts(stringer.set_color(i, i * 100 / 16.0, i * 100 / 16.0, i * 100 / 16.0)) }
+  # puts(stringer.set_color(0, 100, 0, 0) +
+  #      stringer.set_color(1, 0, 100, 0) +
+  #      stringer.set_color(2, 0, 0, 100) +
+  #      stringer.set_color(3, 100, 100, 100))
+  puts(stringer.from_array(arr, 100, 100))
+  puts(stringer.cr)
+  puts(stringer.from_array(arr.collect { |a| arr.max - a }, 100, 100))
+  puts(stringer.newline)
+  puts(stringer.newline)
+  puts(stringer.from_array(line, 40, 100))
+  puts(stringer.finish_sixel)
+
+  v = CooCoo::Vector.new(28 * 28, 2)
+  CooCoo::Drawing::Sixel.with_sixel do |s|
+    s.set_color(0, 0, 0, 0)
+    s.set_color(1, 100, 0, 0)
+    s.set_color(2, 100, 100, 100)
+    s.set_color(3, 100, 0, 100)
+    s.set_color(3, 50, 50, 50)
+    s.from_array(CooCoo::Vector[64.times] / 16, 64, 1)
+    s.from_array(CooCoo::Vector[64.times] / 16, 1, 64)
+    s.from_array(CooCoo::Vector[64.times] / 16, 8, 8)
+    s.newline
+    s.from_array(v, 28)
+    s.newline
+    s.from_array(CooCoo::Vector.new(28 * 28, 3), 28)
+    s.newline
+    s.from_array(CooCoo::Vector.rand(28 * 28, 4), 28)
+  end
+  
+  puts("Good bye.")
+end

data/lib/coo-coo/enum.rb

@@ -0,0 +1,17 @@
+require 'coo-coo/core_ext'
+
+class Enumerator
+  define_once(:zero) do
+    Array.new(size, self.first.zero)
+  end
+  
+  define_once(:sum) do
+    inject(0) do |acc, e|
+      acc += e
+    end
+  end
+
+  define_once(:average) do
+    sum / (size || count)
+  end
+end

data/lib/coo-coo/from_name.rb

@@ -0,0 +1,58 @@
+module CooCoo
+  # Adds class methods to register classes that can be instantiated
+  # using strings.
+  #
+  # To get an instance, use {#from_name}.
+  #
+  # To add classes to the registry, call {#register}, preferably
+  # inside the class definition.
+  module FromName
+    # Adds a class to the registry using the given name.
+    # @param klass [Class] the class to instantiate
+    # @param name [String] name to use when calling #from_name
+    # @return [self]
+    def register(klass, name = nil)
+      @klasses ||= Hash.new
+      @klasses[(name || klass.name).split('::').last] = klass
+      self
+    end
+
+    # @return [Array] of names of all the registered classes.
+    def named_classes
+      @klasses.keys.sort
+    end
+
+    # @return [Enumerator] of all the registered classes.
+    def each(&block)
+      @klasses.each(&block)
+    end
+
+    # Returns an instance of the class registered with the given name.
+    # @param name [String] Registered name of the class with optional arguments in parenthesis.
+    # @param args Additional arguments to pass to the constructor. Overrides any given in the string.
+    # @return An instance of the registered class.
+    def from_name(name, *args)
+      name, params = parse_name(name)
+      klass = @klasses.fetch(name)
+      params = args unless args == nil || args.empty?
+      
+      if params && klass.respond_to?(:new)
+        klass.new(*params)
+      elsif klass.respond_to?(:instance)
+        klass.instance
+      else
+        klass
+      end
+    end
+
+    private
+    def parse_name(name)
+      m = name.match(/(\w+)\((.*)\)/)
+      if m
+        return m[1], m[2].split(',').collect(&:chomp)
+      else
+        return name, nil
+      end
+    end
+  end
+end