CooCoo 0.1.0

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

@@ -0,0 +1,105 @@
+require 'coo-coo/data_sources/xournal/training_document/constants'
+require 'coo-coo/data_sources/xournal/training_document/example'
+
+module CooCoo
+  module DataSources
+    module Xournal
+      class TrainingDocument
+        class DocumentReader
+          def initialize
+          end
+
+          def load(xournal)
+            version, columns, rows, cells_per_example = read_meta_label(xournal)
+            
+            if columns == nil || rows == nil
+              raise ArgumentError.new("Xournal lacks a Text element with '#{META_LABEL} VERSION: COLS ROWS CELLS_PER_EXAMPLE'")
+            end
+
+            doc = TrainingDocument.new
+            
+            xournal.each_page do |page|
+              page.each_layer do |layer|
+                process_layer(doc, page, layer, columns, rows)
+              end
+            end
+
+            doc
+          end
+
+          def read_meta_label(xournal)
+            version = nil
+            columns = nil
+            rows = nil
+            meta = nil
+            
+            xournal.each_page do |page|
+              page.each_layer do |layer|
+                layer.each_text do |txt|
+                  if txt.text =~ /^#{META_LABEL}/
+                    meta = txt.text
+                    break
+                  end
+                end
+              end
+            end
+
+            if meta
+              m = meta.match(META_LABEL_REGEX)
+              version = m[1].to_f
+              columns = m[2].to_i
+              rows = m[3].to_i
+              cells_per_example = (m[4] || 1).to_i
+            end
+
+            return version, columns, rows, cells_per_example
+          end
+          
+          def process_layer(doc, page, layer, columns, rows)
+            grid_w = page.width / columns.to_f
+            grid_h = page.height / rows.to_f
+
+            labels = Hash.new { |h, k| h[k] = Hash.new { |a, b| a[b] = Array.new } }
+            strokes = Hash.new { |h, k| h[k] = Hash.new { |a, b| a[b] = Array.new } }
+            
+            layer.each_text do |txt|
+              next if txt.text =~ /^#{META_LABEL}/
+              row = (txt.y / grid_h).round
+              column = (txt.x / grid_w).round
+              labels[row.to_i][column.to_i] << txt
+            end
+
+            layer.each_stroke do |stroke|
+              color = ChunkyPNG::Color.parse(stroke.color)
+              next if ChunkyPNG::Color.euclidean_distance_rgba(color, PARSED_GRID_COLOR) == 0.0
+              min, max = stroke.minmax
+              row = (min[1] / grid_h)
+              column = (min[0] / grid_w)
+
+              strokes[row.to_i][column.to_i] << stroke
+            end
+            
+
+            rows.times do |row|
+              grid_min_y = (row * grid_h).floor
+
+              columns.times do |column|
+                grid_min_x = (column * grid_w).floor
+                ex_label = labels[row][column].first
+                ex_strokes = strokes[row][column]
+                unless ex_strokes.empty? && ex_label == nil
+                  doc.add_example(ex_label && ex_label.text,
+                                  ex_strokes.collect { |s|
+                                    s.
+                                    translate(-grid_min_x, -grid_min_y).
+                                    scale(1.0 / grid_w, 1.0 / grid_h, 1.0 / grid_w)
+                                  })
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module CooCoo
+  module DataSources
+    module Xournal
+      class TrainingDocument
+        class Example
+          attr_accessor :label
+          attr_reader :stroke_sets
+          
+          def initialize(label, *sets)
+            @label = label
+            @stroke_sets = Array.new
+            sets.each do |points|
+              @stroke_sets << points
+            end
+          end
+
+          def add_set(strokes)
+            @stroke_sets << strokes
+            self
+          end
+          
+          def each_set(&block)
+            @stroke_sets.each(&block)
+          end
+
+          def empty?
+            @stroke_sets.empty?
+          end
+
+          def size
+            @stroke_sets.size
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module CooCoo
+  module DataSources
+    module Xournal
+      class TrainingDocument
+        # Create a {TrainingDocument} for ASCII characters.
+        # @param doc [Document] Optional Document used to extract examples.
+        # @return [TrainingDocument]
+        def self.ascii_trainer(doc = self.new)
+          (32...127).each do |c|
+            c = c.chr[0]
+            doc.add_example(c, [])
+          end
+
+          doc
+        end
+
+        # Create a {TrainingDocument} for an arbitrary Unicode block.
+        # @param starting_offset [Integer] Which Unicode character to start the examples
+        # @param number [Integer] The number of characters to place in the document.
+        # @param doc [Document] Optional Document used to extract examples.
+        # @return [TrainingDocument]
+        def self.unicode_trainer(starting_offset, number, doc = self.new)
+          number.times do |i|
+            doc.add_example("" << (starting_offset + i), [])
+          end
+
+          doc
+        end
+
+        # Create a {TrainingDocument} for Japanese Hiragana, Katakana, and punctuation.
+        # @param doc [Document] Optional Document used to extract examples.
+        # @return [TrainingDocument]
+        def self.jp_trainer(doc = self.new)
+          unicode_trainer(0x3000, 64, doc)
+          unicode_trainer(0x3040, 96, doc)
+          unicode_trainer(0x30A0, 96, doc)
+          unicode_trainer(0xff00, 16 * 15, doc)
+          doc
+        end
+
+        # Create a {TrainingDocument} for the CJK block.
+        # @param limit [Integer] Optional limit on how many characters to include.
+        # @param doc [Document] Optional Document used to extract examples.
+        # @return [TrainingDocument]
+        def self.cjk_trainer(limit = 2000, doc = self.new)
+          unicode_trainer(0x4e00, limit)
+        end
+
+        # Create a {TrainingDocument} for emoji.
+        # @param doc [Document] Optional Document used to extract examples.
+        # @return [TrainingDocument]
+        def self.emoji_trainer(doc = self.new)
+          unicode_trainer(0x1F600, 16 * 5, doc)
+          unicode_trainer(0x2700, 16 * 12, doc)
+        end
+
+        # Create a {TrainingDocument} for math symbols.
+        # @param doc [Document] Optional Document used to extract examples.
+        # @return [TrainingDocument]
+        def self.math_trainer(doc = self.new)
+          unicode_trainer(0x2200, 16 * 16, doc)
+          unicode_trainer(0x2A00, 16 * 16, doc)
+          unicode_trainer(0x2100, 16 * 5, doc)
+          unicode_trainer(0x27C0, 16 * 3, doc)
+          unicode_trainer(0x2980, 16 * 8, doc)
+          unicode_trainer(0x2300, 16 * 16, doc)
+          unicode_trainer(0x25A0, 16 * 6, doc)
+          unicode_trainer(0x2B00, 16 * 16, doc)
+          unicode_trainer(0x2190, 16 * 7, doc)
+          unicode_trainer(0x2900, 16 * 8, doc)
+          unicode_trainer(0x1D400, 16 * 16 * 4, doc)
+        end
+      end
+    end
+  end
+end

data/lib/coo-coo/debug.rb

@@ -0,0 +1,8 @@
+module CooCoo
+  def self.debug(msg, *args)
+    $stderr.puts(msg)
+    args.each do |a|
+      $stderr.puts("\t" + a.to_s)
+    end
+  end
+end

data/lib/coo-coo/dot.rb

@@ -0,0 +1,129 @@
+module CooCoo
+  module Dot
+    class Block
+      attr_reader :options
+      attr_reader :kind
+      
+      def initialize(kind, options)
+        @kind = kind
+        @options = options
+      end
+    end
+
+    class Graph < Block
+      class Node
+        attr_reader :options
+        attr_reader :name
+        
+        def initialize(name, options)
+          @name = name
+          @options = options
+        end
+      end
+
+      class Edge
+        attr_reader :options
+        attr_reader :nodes
+        
+        def initialize(nodes, options = {})
+          @options = options
+          @nodes = nodes.dup
+        end
+
+        def add_node(node)
+          @nodes << node
+          self
+        end
+      end
+
+      attr_reader :nodes, :edges, :blocks
+      
+      def initialize(kind, options)
+        super(kind, options)
+        @nodes = []
+        @edges = []
+        @blocks = []
+        yield(self) if block_given?
+      end
+
+      def add_node(name, options = {})
+        @nodes << Node.new(name, options)
+        self
+      end
+
+      def add_edge(nodes, options = {})
+        @edges << Edge.new(nodes, options)
+        self
+      end
+
+      def add_subgraph(name, options = {}, &block)
+        @blocks << Graph.new("subgraph #{name}", options, &block)
+        self
+      end
+
+      def add_block(type, options = {}, &block)
+        @blocks << Graph.new(type, options, &block)
+        self
+      end
+    end
+    
+    class Writer
+      def initialize
+      end
+
+      def write(graph, io)
+        io.write(write_graph(graph).join("\n"))
+        self
+      end
+
+      def write_graph(g, depth = 0)
+        start_block("#{g.kind}", depth) do |d|
+          lines = []
+          lines += write_graph_options(g, d)
+          g.blocks.each do |kid|
+            lines += write_graph(kid, d)
+          end
+          lines += write_nodes(g.nodes, d)
+          lines += write_edges(g.edges, d)
+          lines
+        end
+      end
+
+      def indent(size)
+        "  " * size
+      end
+
+      def write_graph_options(graph, depth)
+        graph.options.collect do |key, value|
+          indent(depth) + "#{key}=\"#{value}\";"
+        end
+      end
+
+      def start_block(kind, depth)
+        [ indent(depth) + "#{kind} {",
+          *yield(depth + 1),
+          indent(depth) + "}"
+        ]
+      end
+
+      def write_nodes(nodes, depth)
+        nodes.collect do |node|
+          indent(depth) + "#{node.name}[#{write_options(node.options)}];"
+        end
+      end
+
+      def write_edges(edges, depth)
+        edges.collect do |edge|
+          nodes = edge.nodes.join(" -> ")
+          indent(depth) + "#{nodes}[#{write_options(edge.options)}];"
+        end
+      end
+
+      def write_options(options)
+        options.collect do |key, value|
+          "#{key}=\"#{value}\""
+        end.join(",")
+      end
+    end
+  end
+end

data/lib/coo-coo/drawing.rb

@@ -0,0 +1,4 @@
+require 'coo-coo/drawing/canvas'
+require 'coo-coo/drawing/chunky_canvas'
+require 'coo-coo/drawing/cairo_canvas'
+require 'coo-coo/drawing/sixel'

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

@@ -0,0 +1,100 @@
+require 'chunky_png'
+require 'cairo'
+
+module CooCoo
+  module Drawing
+    class CairoCanvas < Canvas
+      attr_reader :surface, :context
+      
+      def initialize(surface_or_width, height = nil)
+        if height
+          surface = Cairo::ImageSurface.new(surface_or_width, height)
+        else
+          surface = surface_or_width
+        end
+        
+        @surface = surface
+        @context = Cairo::Context.new(@surface)
+      end
+
+      def flush
+        @surface.flush
+        self
+      end
+      
+      def line(x1, y1, x2, y2)
+        @context.set_source_rgba(ChunkyPNG::Color.to_truecolor_alpha_bytes(stroke_color))
+        @context.move_to(x1, y1)
+        @context.line_to(x2, y2)
+        @context.stroke
+        self
+      end
+
+      def stroke(points)
+        @context.set_source_rgba(*ChunkyPNG::Color.to_truecolor_alpha_bytes(stroke_color))
+        @context.set_line_width(points[0][2])
+        @context.move_to(points[0][0], points[0][1])
+        @context.line_cap = Cairo::LINE_CAP_ROUND
+        @context.line_join = Cairo::LINE_JOIN_ROUND
+
+        points.each.drop(1).each do |(x, y, w, color)|
+          @context.set_line_width(w)
+          if color
+            @context.set_source_rgba(*ChunkyPNG::Color.to_truecolor_alpha_bytes(color))
+          end
+          @context.line_to(x, y)
+        end
+
+        @context.stroke
+
+        self
+      end
+
+      def rect(x, y, w, h)
+        @context.rectangle(x, y, w, h)
+        @context.set_source_rgba(*ChunkyPNG::Color.to_truecolor_alpha_bytes(fill_color))
+        @context.fill
+        self
+      end
+
+      def circle(x, y, r)
+        @context.circle(x, y, r)
+        @context.set_source_rgba(*ChunkyPNG::Color.to_truecolor_alpha_bytes(fill_color))
+        @context.fill
+        self
+      end
+
+      def blit(img, x, y, w, h)
+        surface = Cairo::ImageSurface.from_png(StringIO.new(img))
+        zx = w / surface.width.to_f
+        zy = h / surface.height.to_f
+        @context.set_source(surface, x / zx, y / zy)
+        @context.scale(zx, zy)
+        @context.paint
+
+        self
+      end
+
+      def text(txt, x, y, font, font_size, style = Cairo::FONT_SLANT_NORMAL)
+        @context.move_to(x, y + font_size)
+        @context.set_source_rgba(*ChunkyPNG::Color.to_truecolor_alpha_bytes(fill_color))
+        @context.select_font_face(font, style)
+        @context.font_size = font_size
+        @context.show_text(txt)
+        self
+      end
+
+      def to_blob
+        data = StringIO.new
+        @surface.write_to_png(data)
+        data.rewind
+        data.read
+      end
+      
+      def to_vector(grayscale = false)
+        @surface.flush
+        chunky_to_vector(ChunkyPNG::Image.from_blob(to_blob), grayscale)
+      end
+    end
+  end
+end