CooCoo 0.1.0

data/lib/coo-coo/data_sources.rb

@@ -0,0 +1,2 @@
+require 'coo-coo/data_sources/xournal.rb'
+require 'coo-coo/data_sources/xournal/training_document.rb'

data/lib/coo-coo/data_sources/xournal.rb

@@ -0,0 +1,25 @@
+require 'coo-coo/data_sources/xournal/document'
+require 'coo-coo/data_sources/xournal/loader'
+require 'coo-coo/data_sources/xournal/saver'
+require 'coo-coo/data_sources/xournal/renderer'
+require 'coo-coo/data_sources/xournal/training_document'
+
+module CooCoo
+  module DataSources
+    module Xournal
+      # Load a Xournal from a file.
+      # @param path [String] The file's path.
+      # @return [Document]
+      def self.from_file(path)
+        Loader.from_file(path)
+      end
+
+      # Load Xournal from an XML string.
+      # @param xml [String] Unprocessed XML
+      # @return [Document]
+      def self.from_xml(xml)
+        Loader.from_xml(xml)
+      end
+    end
+  end
+end

data/lib/coo-coo/data_sources/xournal/bitmap_stream.rb

@@ -0,0 +1,197 @@
+require 'pathname'
+require 'coo-coo/math'
+require 'coo-coo/data_sources/xournal/training_document'
+require 'coo-coo/data_sources/xournal/renderer'
+require 'coo-coo/drawing/cairo_canvas'
+
+module CooCoo
+  module DataSources
+    module Xournal
+      class BitmapStream
+        attr_reader :training_documents
+        attr_reader :labels
+        attr_reader :example_width, :example_height
+        attr_accessor :canvas_klass
+        attr_accessor :pen_scale
+        attr_reader :use_color
+        attr_accessor :shuffle
+        
+        def initialize(options = Hash.new)
+          @training_documents = Array.new
+          @document_paths = Array.new
+          @pen_scale = options.fetch(:pen_scale, 1.0)
+          @example_width = options.fetch(:width, 28)
+          @example_height = options.fetch(:height, 28)
+          @num_labels = options[:num_labels]
+          if options[:labels]
+            @labels = File.read(options[:labels]).split("\n")
+          else
+            @labels = Array.new
+          end
+          @canvas_klass = options.fetch(:canvas, Drawing::CairoCanvas)
+          @use_color = options.fetch(:use_color, false)
+          @shuffle = options.fetch(:shuffle, 16)
+
+          options[:training_documents].each do |td|
+            add_training_document(td)
+          end
+        end
+
+        def add_training_document(path_or_td)
+          td = case path_or_td
+               when String then TrainingDocument.from_file(path_or_td)
+               when Pathname then TrainingDocument.from_file(path_or_td.to_s)
+               when TrainingDocument then path_or_td
+               else raise ArgumentError.new("#{path_or_td.inspect} is not a String, Pathname, or TrainingDocument")
+               end
+          process_training_document(td)
+          @document_paths << path_or_td unless td == path_or_td
+          @training_documents << td
+          self
+        end
+
+        def process_training_document(td)
+          td.labels.each do |l|
+            add_label(l)
+          end
+        end
+
+        def size
+          training_documents.reduce(0) do |total, td|
+            total + td.each_example.reduce(0) do |subtotal, ex|
+              subtotal + ex.size
+            end
+          end
+        end
+        
+        def input_size
+          example_width * example_height * (@use_color ? 3 : 1)
+        end
+        
+        def output_size
+          Math.max(@labels.size, @num_labels)
+        end
+        
+        def add_label(label)
+          @labels << label unless @labels.find_index(label)
+          self
+        end
+
+        def encode_label(label)
+          i = @labels.find_index(label)
+          v = Vector.zeros(output_size)
+          v[i] = 1.0
+          v
+        end
+
+        def decode_output(output)
+          @labels[output.each.with_index.max[1]]
+        end
+
+        def encode_strokes_to_canvas(strokes, canvas)
+          canvas.fill_color = 'white'
+          canvas.stroke_color = 'white'
+          canvas.rect(0, 0, @example_width, @example_height)
+          ren = Renderer.new
+
+          strokes.each do |stroke|
+            ren.render_stroke(canvas, stroke, 0, 0, 1, 1, @example_width, @example_height)
+          end
+        end
+        
+        def encode_strokes(strokes, return_canvas = false)
+          canvas = @canvas_klass.new(@example_width, @example_height)
+          if pen_scale != 1.0
+            strokes = strokes.collect { |s| s.scale(1.0, 1.0, pen_scale) }
+          end
+          
+          encode_strokes_to_canvas(strokes, canvas)
+          
+          if return_canvas
+            canvas.flush
+          else
+            canvas.to_vector(!@use_color) / 256.0
+          end
+        end
+        
+        def each(yield_canvas = false, &block)
+          return to_enum(__method__, yield_canvas) unless block_given?
+
+          training_documents.each do |td|
+            stroke_set = 0
+
+            loop do
+              td.each_example.each_slice(shuffle) do |slice|
+                examples = slice.collect do |ex|
+                  strokes = ex.stroke_sets[stroke_set]
+                  [ ex.label, strokes ] unless strokes.nil? || strokes.empty?
+                end.reject(&:nil?)
+
+                raise StopIteration if examples.empty?
+
+                examples.shuffle.each do |(label, strokes)|
+                  yield(encode_label(label), encode_strokes(strokes, yield_canvas))
+                end
+              end
+              
+              stroke_set += 1
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+if $0 != __FILE__
+  require 'ostruct'
+
+  @options = OpenStruct.new
+  @options.training_documents = Array.new
+  @options.labels_path = nil
+  @options.width = 28
+  @options.height = 28
+  @options.shuffle = 128
+  
+  require 'coo-coo/option_parser'
+
+  @opts = CooCoo::OptionParser.new do |o|
+    o.banner = "Xournal Training Document Bitmap Stream Generator"
+
+    o.on('--data-path PATH', String, 'Adds a Xournal training document to be loaded.') do |p|
+      @options.training_documents += Dir.glob(p).to_a
+    end
+
+    o.on('--data-labels PATH', String, 'Predefined list of labels to preset the one hot encoding.') do |p|
+      @options.labels = p
+    end
+
+    o.on('--data-num-labels NUMBER', Integer, 'Minimum number of labels in the model') do |n|
+      @options.num_labels = n.to_i
+    end
+    
+    o.on('--data-width NUMBER', Integer, 'Width in pixels of the generated bitmaps.') do |n|
+      n = n.to_i
+      raise ArgumentError.new('data-width must be > 0') if n <= 0
+      @options.width = n
+    end
+
+    o.on('--data-height NUMBER', Integer, 'Height in pixels of the generated bitmaps.') do |n|
+      n = n.to_i
+      raise ArgumentError.new('data-height must be > 0') if n <= 0
+      @options.height = n
+    end
+
+    o.on('--data-shuffle NUMBER', Integer, 'Number of examples to shuffle before yielding.') do |n|
+      n = n.to_i
+      raise ArgumentError.new('data-shuffle must be > 0') if n <= 0
+      @options.shuffle = n
+    end
+  end
+
+  def training_set
+    CooCoo::DataSources::Xournal::BitmapStream.new(@options.to_h)
+  end
+  
+  [ method(:training_set), @opts ]
+end

data/lib/coo-coo/data_sources/xournal/document.rb

@@ -0,0 +1,377 @@
+module CooCoo
+  module DataSources
+    module Xournal
+      Colors = %w(black blue red green gray lightblue lightgreen magenta orange yellow white)
+
+      # The root of a Xournal document. Each document contains multiple
+      # {Page pages} which contain {Layer layers} with actual ink {Stroke strokes}, {Text text}, and {Image images}.
+      #
+      # More information on what is allowed can be found at:
+      # {http://xournal.sourceforge.net/manual.html#file-format}
+      class Document
+        VERSION = '0.4.8'
+        
+        attr_accessor :title
+        attr_accessor :version
+        attr_reader :pages
+        
+        def initialize(title = "Untitled Document", version = VERSION)
+          @title = title
+          @version = version
+          @pages = Array.new
+          yield(self) if block_given?
+        end
+
+        def add_page(page)
+          @pages << page
+          self
+        end
+
+        def delete_page_at(page_num)
+          @pages.delete_at(page_num)
+          self
+        end
+
+        def delete_page(page)
+          @pages.delete(page)
+          self
+        end
+
+        def each_page(&block)
+          @pages.each(&block)
+        end
+
+        def size
+          @pages.size
+        end
+
+        def save(*args)
+          Saver.save(self, *args)
+        end
+      end
+
+      class Page
+        attr_accessor :width, :height, :background
+        attr_reader :layers
+
+        def initialize(width, height, background = Background::Default)
+          @width = width
+          @height = height
+          @background = background
+          @layers = Array.new
+          yield(self) if block_given?
+        end
+
+        def add_layer(layer)
+          @layers << layer
+          self
+        end
+
+        def delete_layer_at(layer)
+          @layers.delete_at(layer)
+        end
+
+        def delete_layer(layer)
+          @layers.delete(layer)
+        end
+
+        def each_layer(&block)
+          @layers.each(&block)
+        end
+      end
+
+      class Background
+        attr_accessor :color
+        attr_accessor :style
+
+        Styles = [ 'plain', 'lined', 'ruled', 'graph' ]
+
+        def initialize(color = 'white', style = 'plain')
+          self.color = color
+          self.style = style
+        end
+
+        def style=(s)
+          raise ArgumentError.new("Invalid style #{s}") unless s == nil || Styles.include?(s)
+          @style = s
+        end
+
+        Default = self.new
+      end
+
+      class PixmapBackground
+        attr_accessor :domain
+        attr_accessor :filename
+
+        Domains = [ 'absolute', 'attach', 'clone' ]
+
+        def initialize(filename, domain = 'attach')
+          self.filename = filename
+          self.domain = domain
+        end
+
+        def domain=(d)
+          raise ArgumentError.new("Invalid domain #{d}") unless d == nil || Domains.include?(d)
+          @domain = d
+        end
+      end
+
+      class PDFBackground
+        attr_accessor :domain
+        attr_accessor :filename
+        attr_accessor :page_number
+
+        Domains = [ 'absolute', 'attach' ]
+
+        def initialize(filename, page_number = nil, domain = 'attach')
+          self.filename = filename
+          self.domain = domain
+          self.page_number = page_number
+        end
+
+        def domain=(d)
+          raise ArgumentError.new("Invalid domain #{d}") unless d == nil || Domains.include?(d)
+          @domain = d
+        end
+      end
+      
+      class Layer
+        attr_reader :children
+
+        def initialize
+          @children = Array.new
+        end
+
+        def each(&block)
+          @children.each(&block)
+        end
+
+        def delete_child_at(n)
+          @children.delete_at(n)
+          self
+        end
+
+        def delete_child(child)
+          @children.delete(child)
+          self
+        end
+
+        def add_stroke(stroke)
+          @children << stroke
+          self
+        end
+
+        def strokes
+          @children.select { |c| c.kind_of?(Stroke) }
+        end
+        
+        def each_stroke(&block)
+          strokes.each(&block)
+        end
+
+        def add_text(text)
+          @children << text
+          self
+        end
+
+        def text
+          @children.select { |c| c.kind_of?(Text) }          
+        end
+        
+        def each_text(&block)
+          text.each(&block)
+        end
+
+        def add_image(img)
+          @children << img
+        end
+
+        def images
+          @children.select { |c| c.kind_of?(Image) }          
+        end
+        
+        def each_image(&block)
+          images.each(&block)
+        end
+      end
+
+      class Stroke
+        attr_reader :samples
+        attr_accessor :tool
+        attr_accessor :color
+
+        Tools = [ 'pen', 'highlighter', 'eraser' ]
+        DefaultTool = Tools.first
+
+        def initialize(tool = 'pen', color = 'black', samples = nil)
+          self.tool = tool
+          @color = color
+          @samples = samples || Array.new
+        end
+
+        def tool=(t)
+          raise ArgumentError.new("Invalid tool: #{t.inspect}") unless t == nil || Tools.include?(t)
+          @tool = t
+        end
+
+        def add_sample(x, y, w = 1)
+          @samples << Sample.new(x, y, w)
+          self
+        end
+
+        def delete_sample_at(n)
+          @samples.delete_at(n)
+          self
+        end
+
+        def delete_sample(sample)
+          @samples.delete(sample)
+          self
+        end
+
+        def size
+          @samples.size
+        end
+        
+        def each_sample(&block)
+          @samples.each(&block)
+        end
+        
+        def translate(dx, dy)
+          self.class.new(tool, color, samples.collect { |s| s.translate(dx, dy) })
+        end
+
+        def scale(sx, sy, sw = 1.0)
+          self.class.new(tool, color, samples.collect { |s| s.scale(sx, sy, sw) })
+        end
+        
+        def minmax
+          xmin = nil
+          xmax = nil
+          ymin = nil
+          ymax = nil
+
+          xmin, xmax = @samples.collect(&:x).minmax
+          ymin, ymax = @samples.collect(&:y).minmax
+          
+          [ [ xmin, ymin ], [ xmax, ymax ] ]
+        end
+      end
+
+      class Sample
+        attr_accessor :width, :x, :y
+
+        def initialize(x, y, width = nil)
+          @x = x
+          @y = y
+          @width = width
+        end
+
+        def translate(dx, dy)
+          self.class.new(x + dx, y + dy, width)
+        end
+
+        def scale(sx, sy, sw)
+          self.class.new(x * sx, y * sy, width * sw)
+        end
+      end
+
+      class Text
+        attr_accessor :text, :size, :x, :y, :color, :font
+
+        def initialize(text, x, y, size = 12, color = 'black', font = 'Sans')
+          @text = text
+          @x = x
+          @y = y
+          @size = size
+          @color = color
+          @font = font
+        end
+
+        def left
+          x
+        end
+
+        def top
+          y
+        end
+
+        def right
+          x + width
+        end
+
+        def width
+          # TODO but how?
+          @text.length * @size
+        end
+
+        def bottom
+          y + height
+        end
+
+        def height
+          @size * @text.count("\n")
+        end
+      end
+
+      class Image
+        attr_accessor :left, :right, :top, :bottom
+        attr_accessor :data, :raw_data
+
+        def initialize(left, top, right, bottom, data = nil)
+          @left = left.to_f
+          @top = top.to_f
+          @right = right.to_f
+          @bottom = bottom.to_f
+          self.data = data
+        end
+
+        def data=(data)
+          case data
+          when String then
+            data = Base64.decode64(data)
+            @data = decode_image(data) rescue nil
+            @raw_data = data
+          when ChunkyPNG::Image then
+            @data = data
+            @raw_data = nil
+          when nil then @data = @raw_data = nil
+          else @raw_data = data
+          end
+        end
+
+        def raw_data
+          @raw_data || @data.to_blob
+        end
+
+        def sized_data(zx = 1.0, zy = 1.0)
+          if zx == 1.0 && zy == 1.0
+            @sized_data ||= @data.resample_bilinear(width, height)
+          else
+            @data.resample_bilinear((width * zx).to_i, (height * zy).to_i)
+          end
+        end
+
+        def width
+          (right - left).to_i
+        end
+
+        def height
+          (bottom - top).to_i
+        end
+
+        def decode_image(data)
+          ChunkyPNG::Image.from_string(data)
+        end
+        
+        def data_string
+          Base64.encode64(raw_data)
+        end
+
+        def raw_data
+          @raw_data ||= @data.to_s
+        end
+      end
+    end
+  end
+end