CooCoo 0.1.0

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

@@ -0,0 +1,144 @@
+require 'nokogiri'
+require 'zlib'
+require 'chunky_png'
+require 'base64'
+require 'coo-coo/data_sources/xournal/document'
+
+module CooCoo
+  module DataSources
+    module Xournal
+      # Loads a {Document}.
+      class Loader
+        # General catch all class for load errors.
+        class Error < RuntimeError
+        end
+
+        # Error while parsing the Xournal.
+        class ParseError < Error
+        end
+        
+        def initialize(doc)
+          @doc = doc || Document.new
+        end
+
+        # Loads a Xournal document from the file at +path+.
+        # @return [Document]
+        def self.from_file(path)
+          doc = nil
+          
+          Zlib::GzipReader.open(path) do |io|
+            doc = from_xml(io)
+          end
+
+          doc
+        rescue Zlib::GzipFile::Error
+          from_regular_file(path)
+        end
+
+        # Loads a {Document} from XML in a String.
+        def self.from_xml(data)
+          xml = Nokogiri::XML(data)
+          root = xml.xpath('//xournal')[0]
+          raise ParseError.new("XML root is not 'xournal'") unless root
+          title_el = root.xpath("title")
+          title = title_el[0].text if title_el.size > 0
+          
+          self.
+            new(Document.new(title, root['version'])).
+            from_xml(xml)
+        end
+
+        def from_xml(xml)
+          xml.xpath("//page").each do |page|
+            @doc.add_page(load_page(page))
+          end
+
+          @doc
+        end
+
+        protected
+        
+        def self.from_regular_file(path)
+          File.open(path, 'rb') do |f|
+            from_xml(f)
+          end
+        end
+
+        def load_page(xml)
+          w = xml['width'].to_f
+          h = xml['height'].to_f
+          bg_xml = xml.xpath('background')
+          bg = load_background(bg_xml[0]) if bg_xml[0]
+          page = Page.new(w, h, bg)
+          
+          xml.xpath('layer').each do |layer|
+            page.add_layer(load_layer(layer))
+          end
+
+          page
+        end
+
+        def load_background(xml)
+          case xml['type']
+          when 'pixmap' then PixmapBackground.new(xml['filename'], xml['domain'])
+          when 'pdf' then PDFBackground.new(xml['filename'], xml['pageno'], xml['domain'])
+          when 'solid' then Background.new(xml['color'], xml['style'])
+          else raise ParseError.new("Unknown background type #{xml['type']}: #{xml}")
+          end
+        end
+
+        def load_layer(xml)
+          layer = Layer.new
+
+          xml.children.select(&:element?).each do |elem|
+            case elem.name
+            when 'stroke' then layer.add_stroke(load_stroke(elem))
+            when 'text' then layer.add_text(load_text(elem))
+            when 'image' then layer.add_image(load_image(elem))
+            else raise ParseError.new("Unknown element: #{elem}")
+            end
+          end
+          
+          layer
+        end
+
+        def load_image(xml)
+          Image.new(xml['left'],
+                    xml['top'],
+                    xml['right'],
+                    xml['bottom'],
+                    xml.text)
+        end
+        
+        def load_text(xml)
+          Text.new(xml.text,
+                   xml['x'].to_f,
+                   xml['y'].to_f,
+                   xml['size'].to_f,
+                   xml['color'],
+                   xml['font'])
+        end
+
+        def load_stroke(xml)
+          tool = xml['tool']
+          tool = Stroke::DefaultTool if tool == nil || tool.empty?
+          color = xml['color']
+          stroke = Stroke.new(tool, color)
+          widths = xml['width'].split.collect(&:to_f)
+
+          width = nil
+          xml.children.to_s.
+            split.
+            collect(&:to_f).
+            each_slice(2).
+            zip(widths) do |(x, y), w|
+            width ||= w if w
+            stroke.add_sample(x, y, width)
+          end
+
+          stroke
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+require 'chunky_png'
+require 'cairo'
+require 'coo-coo/drawing'
+
+module CooCoo
+  module DataSources
+    module Xournal
+      class Renderer
+        def initialize()
+        end
+
+        def render(*args)
+          render_to_chunky(*args)
+        end
+
+        def render_to_canvas(canvas, document, page_num, x = 0, y = 0, w = nil, h = nil, zx = 1.0, zy = 1.0)
+          page = document.pages[page_num]
+          w ||= (page.width - x).ceil.to_i
+          h ||= (page.height - y).ceil.to_i
+          render_page(canvas, page, x, y, x + w, y + h, zx, zy)
+          canvas
+        end
+        
+        def render_to_chunky(document, page_num, x = 0, y = 0, w = nil, h = nil, zx = 1.0, zy = 1.0)
+          page = document.pages[page_num]
+          w ||= (page.width - x).ceil.to_i
+          h ||= (page.height - y).ceil.to_i
+          img = ChunkyPNG::Image.new((w * zx).to_i, (h * zy).to_i, chunky_color(page.background.color || :white))
+          canvas = Drawing::ChunkyCanvas.new(img)
+          render_to_canvas(canvas, document, page_num, x, y, w, h, zx, zy)
+          img
+        end
+        
+        def render_to_cairo(document, page_num, x = 0, y = 0, w = nil, h = nil, zx = 1.0, zy = 1.0)
+          page = document.pages[page_num]
+          w ||= (page.width - x).ceil.to_i
+          h ||= (page.height - y).ceil.to_i
+          surface = Cairo::ImageSurface.new((w * zx).to_i, (h * zy).to_i)
+          canvas = Drawing::CairoCanvas.new(surface)
+          render_to_canvas(canvas, document, page_num, x, y, w, h, zx, zy)
+          surface
+        end
+
+        def chunky_color(color)
+          color && ChunkyPNG::Color.parse(color)
+        end
+        
+        def render_page(canvas, page, min_x, min_y, max_x, max_y, zx, zy)
+          render_background(canvas, page.background, min_x, min_y, max_x, max_y, zx, zy)
+          page.each_layer do |layer|
+            render_layer(canvas, layer, min_x, min_y, max_x, max_y, zx, zy)
+          end
+        end
+
+        def render_background(canvas, bg, min_x, min_y, max_x, max_y, zx, zy)
+          color = chunky_color(bg.color || :white)
+          canvas.stroke_color = canvas.fill_color = color
+          canvas.rect(0, 0, ((max_x - min_x) * zx).to_i, ((max_y - min_y) * zy).to_i)
+        end
+
+        def render_layer(canvas, layer, min_x, min_y, max_x, max_y, zx, zy)
+          layer.each do |child|
+            #next unless child.within?(min_x, min_y, max_x, max_y)
+            case child
+            when Image then render_image(canvas, child, min_x, min_y, zx, zy)
+            when Stroke then render_stroke(canvas, child, min_x, min_y, max_x, max_y, zx, zy)
+            when Text then render_text(canvas, child, min_x, min_y, zx, zy)
+            end
+          end
+        end
+
+        def render_image(canvas, src, min_x, min_y, zx, zy)
+          canvas.blit(src.raw_data, ((src.left - min_x) * zx), ((src.top - min_y) * zy), src.width * zx, src.height * zy)
+        end
+
+        def render_stroke(canvas, stroke, min_x, min_y, max_x, max_y, zx, zy)
+          points = stroke.each_sample.inject([]) do |acc, sample|
+            #next unless sample.within?(min_x, min_y, max_x, max_y)
+            acc << [ (sample.x - min_x) * zx,
+                     (sample.y - min_y) * zy,
+                     sample.width * zx
+                   ]
+          end
+
+          canvas.stroke_color = chunky_color(stroke.color)
+          canvas.fill_color = chunky_color(stroke.color)
+          canvas.stroke(points)
+        end
+
+        def render_text(canvas, text, min_x, min_y, zx, zy)
+          canvas.fill_color = chunky_color(text.color)
+          canvas.text(text.text,
+                      (text.x - min_x) * zx,
+                      (text.y - min_y) * zy,
+                      text.font,
+                      text.size * zy)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+module CooCoo
+  module DataSources
+    module Xournal
+      # Saves a {Document}
+      # @todo Keep linked images with the Xournal when it is saved.
+      class Saver
+        # Saves +doc+ to +io_or_path+ using Xournal's compressed XML format.
+        # @param io_or_path [String, IO] File name or an IO
+        def self.save(doc, io_or_path)
+          new.save(doc, io_or_path)
+        end
+
+        # Saves +doc+ to an XML string.
+        def self.to_xml(doc)
+          new.to_xml(doc)
+        end
+
+        def initialize
+        end
+
+        def save(doc, io_or_path)
+          if io_or_path.respond_to?(:write)
+            save_to_io(doc, io_or_path)
+          elsif io_or_path.kind_of?(String)
+            save_to_file(doc, io_or_path)
+          else
+            raise ArgumentError.new("Only paths as String and IO are supported outputs. Not #{io_or_path.class}")
+          end
+        end
+
+        def to_xml(doc)
+          Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+            xml.xournal(version: doc.version) do
+              xml.title(doc.title)
+              doc.pages.each do |p|
+                page_to_xml(p, xml)
+              end
+            end
+          end.to_xml
+        end
+
+        protected
+        
+        def save_to_file(doc, path)
+          Zlib::GzipWriter.open(path) do |f|
+            save_to_io(doc, f)
+          end
+        end
+        
+        def save_to_io(doc, io)
+          io.write(to_xml(doc))
+        end
+
+        def page_to_xml(p, xml)
+          xml.page(width: p.width, height: p.height) do
+            background_to_xml(p.background || Background::Default, xml)
+            p.layers.each do |l|
+              layer_to_xml(l, xml)
+            end
+          end
+        end
+
+        def background_to_xml(bg, xml)
+          case bg
+          when PixmapBackground then xml.background(type: 'pixmap', domain: bg.domain, filename: bg.filename)
+          when PDFBackground then xml.background(type: 'pdf', domain: bg.domain, filename: bg.filename, pageno: bg.page_number)
+          else xml.background(type: 'solid', color: bg.color, style: bg.style)
+          end
+        end
+
+        def layer_to_xml(layer, xml)
+          xml.layer do
+            layer.each do |child|
+              case child
+              when Image then image_to_xml(child, xml)
+              when Stroke then stroke_to_xml(child, xml)
+              when Text then text_to_xml(child, xml)
+              else raise ParseError.new("Unknown layer child: #{child.class} #{child.inspect}")
+              end
+            end
+          end
+        end
+
+        def image_to_xml(img, xml)
+          xml.image(img.data_string, left: img.left, top: img.top, right: img.right, bottom: img.bottom)
+        end
+
+        def stroke_to_xml(stroke, xml)
+          xml.stroke(stroke.samples.collect { |s| [ s.x, s.y ] }.flatten.join(' '),
+                     tool: stroke.tool, color: stroke.color, width: stroke.samples.collect(&:width).join(' '))
+        end
+
+        def text_to_xml(text, xml)
+          xml.text_(text.text, x: text.x, y: text.y, size: text.size, color: text.color, font: text.font)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+require 'coo-coo/data_sources/xournal/training_document/constants'
+require 'coo-coo/data_sources/xournal/training_document/example'
+require 'coo-coo/data_sources/xournal/training_document/document_maker'
+require 'coo-coo/data_sources/xournal/training_document/document_reader'
+require 'coo-coo/data_sources/xournal/training_document/sets'
+
+module CooCoo
+  module DataSources
+    module Xournal
+      # The {TrainingDocument} is the source of strokes for the trainer of
+      # the Xournal recognizer. Each {TrainingDocument} has a set of labels
+      # and associated strokes. Examples are loaded and stored to Xournal
+      # documents formatted into a grid with a label and strokes in each cell.
+      class TrainingDocument
+        attr_reader :examples
+
+        # @param examples [Array<Example>]
+        def initialize(examples = nil)
+          @examples = examples || Hash.new { |h, k| h[k] = Example.new(k) }
+        end
+
+        # @return [Integer] Number of examples
+        def size
+          @examples.size
+        end
+
+        # @return [Array<String>] of every example's label
+        def labels
+          @examples.keys
+        end
+
+        # Add an example to the set.
+        # @param label [String] The label of the example.
+        # @param strokes [Array<Stroke>] Strokes associated with this label.
+        # @return self
+        def add_example(label, strokes = nil)
+          ex = @examples[label]
+          ex.add_set(strokes) if strokes && !strokes.empty?
+          self
+        end
+
+        # Iterates each {Example}.
+        # @return [Enumerator]
+        def each_example(&block)
+          return to_enum(__method__) unless block_given?
+
+          @examples.each do |label, ex|
+            block.call(ex)
+          end
+        end
+
+        # Convert the {Example} set into a {Document}.
+        # @param columns [Integer] Number of examples across the page.
+        # @param rows [Integer] Number of examples down the page.
+        # @param page_width [Float] Width of the page in points.
+        # @param page_height [Float] Height of the page in points.
+        # @return [Document]
+        def to_document(columns, rows, cells_per_example = 4, page_width = 612, page_height = 792)
+          DocumentMaker.new(self, columns, rows, cells_per_example, page_width, page_height).make_document
+        end
+
+        # Load {TrainingDocument} from a Xournal file.
+        # @param io_or_path [IO, String]
+        # @return [TrainingDocument]
+        def self.from_file(io_or_path)
+          DocumentReader.new.load(Xournal.from_file(io_or_path))
+        end
+
+        # Load a {TrainingDocument} from a {Document}.
+        # @param doc [Document]
+        # @return [TrainingDocument]
+        def self.from_document(doc)
+          DocumentReader.new.load(doc)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'chunky_png'
+
+module CooCoo
+  module DataSources
+    module Xournal
+      class TrainingDocument
+        VERSION = '1'
+        GRID_COLOR = '#00E0FFFF' # FIXME Xournal places alpha up front
+        PARSED_GRID_COLOR = ChunkyPNG::Color.parse(GRID_COLOR)
+        META_LABEL = "Training Document"
+        META_LABEL_REGEX = /^#{META_LABEL}( +\d+)?: *(\d+)( +\d+)( +\d+)?/
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+require 'coo-coo/data_sources/xournal/document'
+
+module CooCoo
+  module DataSources
+    module Xournal
+      class TrainingDocument
+        class DocumentMaker
+          attr_reader :page_width
+          attr_reader :page_height
+          attr_reader :cells_per_example
+          attr_reader :columns
+          attr_reader :rows
+
+          def initialize(training_doc, columns, rows, cells_per_example, page_width, page_height)
+            @doc = training_doc
+            @columns = columns
+            @rows = rows
+            @cells_per_example = cells_per_example
+            @page_width = page_width
+            @page_height = page_height
+          end
+
+          def make_document
+            Document.new do |d|
+              @doc.each_example.each_slice(@columns * @rows / @cells_per_example).with_index do |labels, page_num|
+                d.add_page(make_page(labels, page_num))
+              end
+
+              d.pages.first.layers.last.add_text(Text.new("#{META_LABEL} #{VERSION}: #{@columns} #{@rows} #{@cells_per_example}", 0, @page_height - 14, 12, 'gray'))
+            end
+          end
+
+          def make_cell(layer, label, strokes, x, y, grid_w, grid_h)
+            layer.add_text(Text.new(label, x + 1, y + 1, 12, 'black', 'Serif'))
+            strokes.each do |stroke|
+              layer.add_stroke(stroke.scale(grid_w, grid_h, grid_w).translate(x, y))
+            end
+          end
+          
+          def make_cells(examples, grid_w, grid_h)
+            layer = Layer.new
+
+            examples = examples.collect { |e|
+              e.each_set.collect { |s|
+                [ e.label, s ]
+              } + Array.new(@cells_per_example - e.size, [ e.label, [] ])
+            }.flatten(1)
+
+            examples.each_slice(@columns).with_index do |row, y|
+              row.each_with_index do |(label, strokes), x|
+                make_cell(layer, label, strokes, x * grid_w, y * grid_h, grid_w, grid_h)
+              end
+            end
+
+            layer
+          end
+
+          def make_grid(grid_w, grid_h)
+            grid_layer = Layer.new
+
+            (1...@rows).each do |y|
+              (1...@columns).each do |x|
+                grid_layer.add_stroke(Stroke.new('pen', GRID_COLOR).
+                                      add_sample(x * grid_w, 0).
+                                      add_sample(x * grid_w, @page_height))
+              end
+
+              grid_layer.add_stroke(Stroke.new('pen', GRID_COLOR).
+                                    add_sample(0, y * grid_h).
+                                    add_sample(@page_width, y * grid_h))
+            end
+
+            grid_layer
+          end
+          
+          def make_page(examples, page_num)
+            grid_w = @page_width / @columns
+            grid_h = @page_height / @rows
+            
+            Page.new(@page_width, @page_height).
+              add_layer(make_grid(grid_w, grid_h)).
+              add_layer(make_cells(examples, grid_w, grid_h))
+          end
+        end
+      end
+    end
+  end
+end
+