kvg_character_recognition 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a14886233c4152851248456913d18768d9c8472a
+  data.tar.gz: f29d6c47b40ce1eb68a4db14c3b03961c275197c
+SHA512:
+  metadata.gz: 339db4a0b7e01108b9d105f688dfb4bba6ea81420bb4255b70f1ff8ef51c5ae04cab3424464e453632f2ea17727f2e1629a95148d06379720f5e1cae448fa4a8
+  data.tar.gz: 2f57226b5dac0f9311bf0c5dec2750354aa6c40c5348e2f1df858b52a470aed242aa380be1d4aadfd2d9a1753e5fbad0a1a621a232d28d5e81b3dde4b2c929d9

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kvg_character_recognition.gemspec
+gemspec
+
+gem 'sequel'
+gem 'sqlite3'
+gem 'nokogiri'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jiayi Zheng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,96 @@
+# KvgCharacterRecognition
+KvgCharacterRecognition module contains a CJK-character recognition engine which uses pattern/template matching techniques to achieve recognitionof stroke-order and stroke-number free handwritten character patterns in the format [stroke1, stroke2 ...].
+A stroke is an array of points in the format [[x1, y1], [x2, y2], ...].
+For templates, we use svg data from the [KanjiVG project](http://kanjivg.tagaini.net/)
+
+The engine takes 3 steps to perform the recognition of an input pattern.
+1. Preprocessing
+The preprocessing step consists of smoothing, normalizing, interpolating and downsampling of the data points.
+2. Feature Extraction
+Smoothed heatmap, significant points and directional feature densities are used as features.
+A heatmap divides the input pattern in small grids and stores the number of data points in each grid.
+Significant points are defined as start and end point of a stroke, points on curve or edge.
+Directional feature densities are introduced in the paper "On-line Recognition of Freely Handwritten Japanese Character Using Directional Feature Density"
+3. Matching
+We use the significant points to perform a coarse recognition of the input pattern, that filters out template patterns with great distance to the input pattern. Next, a mixed distance score of directional feature density and smoothed heatmap is calculated.
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'kvg_character_recognition'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kvg_character_recognition
+
+## Usage
+
+1. Create a database(e.g. using sqlite3 data.db)
+
+2. Setup the characters table in the database and populate it with kanjivg templates from the [xml release](https://github.com/KanjiVG/kanjivg/releases)
+```ruby
+require 'kvg_character_recognition'
+
+KvgCharacterRecognition::Database.setup
+
+KvgCharacterRecognition::Database.populate_from_xml "kanjivg-20150615-2.xml"
+```
+
+3. Recognition
+
+Use an input field of size 300x300 for the best recognition accuracy. The input pattern in the example is the character 二, drawn on a 300x300 html canvas using mouse.
+```ruby
+strokes = [[[99.0, 108.0], [100.0, 108.0], [101.0, 108.0], [101.0, 108.0], [103.0, 108.0], [105.0, 107.0], [107.0, 107.0], [108.0, 107.0], [111.0, 106.0], [111.0, 106.0], [112.0, 106.0], [113.0, 106.0], [114.0, 106.0], [115.0, 105.0], [116.0, 105.0], [118.0, 105.0], [120.0, 105.0], [121.0, 104.0], [122.0, 104.0], [122.0, 104.0], [123.0, 104.0], [124.0, 103.0], [125.0, 103.0], [126.0, 103.0], [127.0, 103.0], [129.0, 102.0], [130.0, 102.0], [132.0, 102.0], [132.0, 101.0], [133.0, 101.0], [135.0, 101.0], [136.0, 101.0], [137.0, 101.0], [138.0, 101.0], [140.0, 101.0], [141.0, 100.0], [142.0, 100.0], [143.0, 100.0], [144.0, 100.0], [145.0, 99.0], [148.0, 99.0], [150.0, 99.0], [151.0, 98.0], [152.0, 98.0], [153.0, 98.0], [154.0, 98.0], [156.0, 97.0], [157.0, 97.0], [158.0, 97.0], [159.0, 97.0], [161.0, 97.0], [162.0, 96.0], [162.0, 96.0], [164.0, 96.0], [165.0, 96.0], [166.0, 96.0], [167.0, 96.0], [169.0, 95.0], [170.0, 95.0], [171.0, 95.0], [172.0, 95.0], [173.0, 95.0], [174.0, 95.0]], [[53.0, 190.0], [54.0, 190.0], [56.0, 190.0], [57.0, 190.0], [59.0, 190.0], [61.0, 190.0], [63.0, 189.0], [66.0, 189.0], [67.0, 189.0], [68.0, 189.0], [69.0, 189.0], [71.0, 189.0], [72.0, 188.0], [72.0, 188.0], [74.0, 188.0], [76.0, 187.0], [78.0, 187.0], [80.0, 187.0], [81.0, 187.0], [82.0, 186.0], [84.0, 186.0], [87.0, 186.0], [89.0, 185.0], [91.0, 185.0], [93.0, 185.0], [95.0, 184.0], [98.0, 184.0], [100.0, 183.0], [102.0, 183.0], [104.0, 183.0], [106.0, 183.0], [110.0, 182.0], [111.0, 182.0], [112.0, 182.0], [115.0, 182.0], [118.0, 182.0], [120.0, 182.0], [122.0, 182.0], [125.0, 182.0], [128.0, 181.0], [130.0, 181.0], [133.0, 180.0], [136.0, 180.0], [141.0, 180.0], [143.0, 179.0], [146.0, 179.0], [150.0, 179.0], [152.0, 178.0], [155.0, 178.0], [158.0, 178.0], [159.0, 178.0], [162.0, 177.0], [164.0, 177.0], [167.0, 177.0], [170.0, 177.0], [173.0, 176.0], [176.0, 176.0], [179.0, 176.0], [182.0, 175.0], [187.0, 175.0], [189.0, 174.0], [192.0, 174.0], [194.0, 174.0], [196.0, 173.0], [199.0, 173.0], [202.0, 173.0], [204.0, 172.0], [206.0, 172.0], [209.0, 172.0], [211.0, 172.0], [212.0, 172.0], [215.0, 172.0], [217.0, 172.0], [219.0, 171.0], [221.0, 171.0], [221.0, 172.0]]]
+
+scores = KvgCharacterRecognition::Recognizer.scores strokes
+
+irb(main):004:0> scores.take 10
+=> [[1.524079282599697, 60, "二"], [2.8346163809971143, 1373, "工"], [3.0987422100694757, 7, "上"], [3.127346308294038, 365, "冫"], [3.439293212191952, 6, "三"], [3.4890481845638304, 3770, "立"], [3.541524904953307, 2721, "江"], [3.641178875851016, 569, "厂"], [3.6447144433336294, 72, "亠"], [3.7498483818966353, 2706, "氵"]]
+```
+
+## Configuration
+You can try out different parameters for adapting the extracted features to your input settings i.e. other sample rate, size
+Don't forget to redo the whole database step after changing the configuration.
+```ruby
+  #this is the default configuration
+  config = {
+    size: 109, #fixed canvas size of kanjivg data
+    downsample_interval: 4,
+    interpolate_distance: 0.8,
+    direction_grid: 15,
+    smoothed_heatmap_grid: 20,
+    significant_points_heatmap_grid: 3
+  }
+
+  #from hash
+  Kvgcharacterrecognition.configure(config)
+  #from yaml file
+  Kvgcharacterrecognition.configure_with(path_to_yml)
+
+  #configure database with yml
+  #TODO why is postgres slower than sqlite?
+  Kvgcharacterrecognition.configure_database(path_to_yml)
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/kvg_character_recognition.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "kvg_character_recognition"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/kvg_character_recognition.gemspec

@@ -0,0 +1,40 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kvg_character_recognition/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kvg_character_recognition"
+  spec.version       = KvgCharacterRecognition::VERSION
+  spec.authors       = ["Jiayi Zheng"]
+  spec.email         = ["thebluber@gmail.com"]
+
+  spec.summary       = "CJK-character recognition using template matching techniques and template data from KanjiVG project"
+  spec.description   = %q{This gem contains a CJK-character recognition engine using pattern/template matching techniques.
+  It can recognize stroke-order and stroke-number free handwritten character patterns in the format [stroke1, stroke2 ...].
+  A stroke is an array of points in the format [[x1, y1], [x2, y2], ...].
+  KanjiVG data(characters in svg format) from https://github.com/KanjiVG/kanjivg/releases are used as templates.
+  }
+  spec.homepage      = "https://github.com/thebluber/kvg_character_recognition"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "nokogiri"
+  spec.add_dependency "sequel"
+  spec.add_dependency "sqlite3"
+  spec.add_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/lib/kvg_character_recognition.rb

@@ -0,0 +1,55 @@
+require 'bundler'
+Bundler.require
+require 'yaml'
+#require all files in ./lib/
+Dir[File.join(File.dirname(__FILE__), '/kvg_character_recognition/*.rb')].each {|file| require file }
+
+module KvgCharacterRecognition
+
+  @db = Sequel.connect('sqlite://characters.db')
+  CONFIG = {
+    size: 109, #fixed canvas size of kanjivg data
+    downsample_interval: 4,
+    interpolate_distance: 0.8,
+    direction_grid: 15,
+    smoothed_heatmap_grid: 20,
+    significant_points_heatmap_grid: 3
+  }
+  VALID_KEYS = CONFIG.keys
+
+  #Configure through hash
+  def self.configure(opts = {})
+    opts.each {|k,v| CONFIG[k.to_sym] = v if VALID_KEYS.include? k.to_sym}
+  end
+
+  #Configure with yaml
+  def self.configure_with(yml)
+    begin
+      config = YAML::load(IO.read(yml))
+    rescue Errno::ENOENT
+      log(:warning, "YAML configuration file couldn't be found. Using defaults."); return
+    rescue Psych::SyntaxError
+      log(:warning, "YAML configuration file contains invalid syntax. Using defaults."); return
+    end
+
+    configure(config)
+  end
+
+  #Configure database
+  def self.configure_database(yml)
+    begin
+      db_config = YAML::load(IO.read(yml))
+    rescue Errno::ENOENT
+      log(:warning, "YAML configuration file couldn't be found. Using defaults."); return
+    rescue Psych::SyntaxError
+      log(:warning, "YAML configuration file contains invalid syntax. Using defaults."); return
+    end
+    @db = Sequel.connect(yml)
+  end
+
+  #getter
+  def self.db
+    @db
+  end
+
+end

data/lib/kvg_character_recognition/database.rb

@@ -0,0 +1,103 @@
+require 'matrix'
+require 'nokogiri'
+
+module KvgCharacterRecognition
+  #This class contains methods for database interactions
+  class Database
+
+    #This method creates a database table for storing the extracted features of the templates
+    #Arrays of points will be serialized and stored as string
+    #Following fields are created:
+    # - primary_key :id
+    # - String :value
+    # - Integer :codepoint
+    # - String :serialized_strokes i.e. [stroke, x, y]
+    # - String :direction_e1
+    # - String :direction_e2
+    # - String :direction_e3
+    # - String :direction_e4
+    # - String :heatmap_smoothed
+    # - String :heatmap_significant_points
+    def self.setup
+      KvgCharacterRecognition.db.create_table :characters do
+        primary_key :id
+        String :value
+        Integer :codepoint
+        Integer :number_of_strokes
+        String :serialized_strokes
+        String :direction_e1
+        String :direction_e2
+        String :direction_e3
+        String :direction_e4
+        String :heatmap_smoothed
+        String :heatmap_significant_points
+      end
+
+    end
+
+    #Drop created table
+    def self.drop
+      KvgCharacterRecognition.db.drop_table(:characters) if KvgCharacterRecognition.db.table_exists?(:characters)
+    end
+
+    #This method populates the database table with parsed template patterns from the kanjivg file in xml format
+    #Params:
+    #+xml+:: download the latest xml release from https://github.com/KanjiVG/kanjivg/releases
+    def self.populate_from_xml xml
+      file = File.open(xml) { |f| Nokogiri::XML(f) }
+
+      file.xpath("//kanji").each do |kanji|
+        #id has format: "kvg:kanji_CODEPOINT"
+        codepoint = kanji.attributes["id"].value.split("_")[1]
+        next unless codepoint.hex >= "04e00".hex && codepoint.hex <= "09faf".hex
+        puts codepoint
+        value = [codepoint.hex].pack("U")
+
+        #Preprocessing
+        #--------------
+        #parse strokes
+        strokes = kanji.xpath("g//path").map{|p| p.attributes["d"].value }.map{ |stroke| KvgParser::Stroke.new(stroke).to_a }
+        #strokes in the format [[[x1, y1], [x2, y2] ...], [[x2, y2], [x3, y3] ...], ...]
+        strokes = Preprocessor.preprocess(strokes, CONFIG[:interpolate_distance], CONFIG[:downsample_interval], false)
+
+        #serialize strokes
+        serialized = strokes.map.with_index do |stroke, i|
+          stroke.map{ |p| [i, p[0], p[1]] }
+        end
+
+        points = strokes.flatten(1)
+
+        #Feature Extraction
+        #--------------
+        #20x20 heatmap smoothed
+        heatmap_smoothed = FeatureExtractor.smooth_heatmap(FeatureExtractor.heatmap(points, CONFIG[:smoothed_heatmap_grid], CONFIG[:size]))
+
+        #directional feature densities
+        #transposed from Mx4 to 4xM
+        direction = Matrix.columns(FeatureExtractor.spatial_weight_filter(FeatureExtractor.directional_feature_densities(strokes, CONFIG[:direction_grid])).to_a).to_a
+
+        #significant points
+        significant_points = Preprocessor.significant_points(strokes)
+
+        #3x3 heatmap of significant points for coarse recognition
+        heatmap_significant_points = FeatureExtractor.heatmap(significant_points, CONFIG[:significant_points_heatmap_grid], CONFIG[:size])
+
+
+        #Store to database
+        #--------------
+        KvgCharacterRecognition.db[:characters].insert value: value,
+          codepoint: codepoint.hex,
+          number_of_strokes: strokes.count,
+          serialized_strokes: serialized.join(","),
+          direction_e1: direction[0].join(","),
+          direction_e2: direction[1].join(","),
+          direction_e3: direction[2].join(","),
+          direction_e4: direction[3].join(","),
+          heatmap_smoothed: heatmap_smoothed.to_a.join(","),
+          heatmap_significant_points: heatmap_significant_points.to_a.join(",")
+      end
+
+    end
+
+  end
+end

data/lib/kvg_character_recognition/feature_extractor.rb

@@ -0,0 +1,168 @@
+require 'matrix'
+module KvgCharacterRecognition
+  #This class contains a collection of methods for extracting useful features
+  class FeatureExtractor
+
+    #This methods generates a heatmap for the given character pattern
+    #A heatmap divides the input character pattern(image of the character) into nxn grids
+    #We count the points in each grid and store the number in a map
+    #The map array can be used as feature
+    #Params:
+    #+points+:: flattened strokes i.e. [[x1, y1], [x2, y2]...] because the seperation of points in strokes is irrelevant in this case
+    #+grid+:: number of grids
+    def self.heatmap points, grid, size
+
+      grid_size = size / grid.to_f
+
+      map = Map.new grid, grid, 0
+
+      #fill the heatmap
+      points.each do |point|
+        if point[0] < size && point[1] < size
+          x_i = (point[0] / grid_size).floor if point[0] < size
+          y_i = (point[1] / grid_size).floor if point[1] < size
+
+          map[y_i, x_i] = map[y_i, x_i] + 1
+        end
+      end
+
+      map
+    end
+
+    #This method calculates the directional feature densities and stores them in a map
+    #The process and algorithm is described in the paper "On-line Recognition of Freely Handwritten Japanese Characters Using Directional Feature Densities" by Akinori Kawamura and co.
+    #Params:
+    #+strokes+:: [[[x1, y1], [x2, y2] ...], [[x1, y1], ...]]]
+    #+grid+:: number of grids in which the input character pattern should be seperated. Default is 15 as in the paper
+    def self.directional_feature_densities strokes, grid
+      #initialize a map for storing the weights in each directional space
+      map = Map.new grid, grid, [0, 0, 0, 0]
+
+      #step width
+      step = CONFIG[:size] / grid.to_f
+
+      strokes.each do |stroke|
+        current_p = stroke[0]
+        stroke.each do |point|
+          next if point == current_p
+          #map current point coordinate to map index
+          #i_x = xth column
+          #i_y = yth row
+          i_x = (current_p[0] / step).floor
+          i_y = (current_p[1] / step).floor
+
+          #direction vector V_ij = P_ij+1 - P_ij
+          v = [point[0] - current_p[0], point[1] - current_p[1]]
+          #store the sum of decomposed direction vectors in the corresponding grid
+          decomposed = decompose(v)
+          map[i_y, i_x] = [map[i_y, i_x][0] + decomposed[0],
+                           map[i_y, i_x][1] + decomposed[1],
+                           map[i_y, i_x][2] + decomposed[2],
+                           map[i_y, i_x][3] + decomposed[3]]
+        end
+      end
+      map
+    end
+
+    #This method is a helper method for calculating directional feature density
+    #which decomposes the direction vector into predefined direction spaces
+    #- e1: [1, 0]
+    #- e2: [1/sqrt(2), 1/sqrt(2)]
+    #- e3: [0, 1]
+    #- e4: [-1/sqrt(2), 1/sqrt(2)]
+    #Params:
+    #+v+:: direction vector of 2 adjacent points V_ij = P_ij+1 - P_ij
+    def self.decompose v
+      e1 = [1, 0]
+      e2 = [1/Math.sqrt(2), 1/Math.sqrt(2)]
+      e3 = [0, 1]
+      e4 = [-1/Math.sqrt(2), 1/Math.sqrt(2)]
+      #angle between vector v and e1
+      #det = x1*y2 - x2*y1
+      #dot = x1*x2 + y1*y2
+      #atan2(det, dot) in range 0..180 and 0..-180
+      angle = (Math.atan2(v[1], v[0]) / (Math::PI / 180)).floor
+      if (0..44).cover?(angle) || (-180..-136).cover?(angle)
+        decomposed = [(Matrix.columns([e1, e2]).inverse * Vector.elements(v)).to_a, 0, 0].flatten
+      elsif (45..89).cover?(angle) || (-135..-91).cover?(angle)
+        decomposed = [0, (Matrix.columns([e2, e3]).inverse * Vector.elements(v)).to_a, 0].flatten
+      elsif (90..134).cover?(angle) || (-90..-44).cover?(angle)
+        decomposed = [0, 0, (Matrix.columns([e3, e4]).inverse * Vector.elements(v)).to_a].flatten
+      elsif (135..179).cover?(angle) || (-45..-1).cover?(angle)
+        tmp = (Matrix.columns([e4, e1]).inverse * Vector.elements(v)).to_a
+        decomposed = [tmp[0], 0, 0, tmp[1]]
+      end
+
+      decomposed
+    end
+
+    #This methods reduces the dimension of directonal feature densities stored in the map
+    #It takes every 2nd grid of directional_feature_densities map and stores the average of the weighted sum of adjacent grids around it
+    #weights = [1/16, 2/16, 1/16];
+    #          [2/16, 4/16, 2/16];
+    #          [1/16, 2/16, 1/16]
+    #Params:
+    #+map+:: directional feature densities map i.e. [[e1, e2, e3, e4], [e1, e2, e3, e4] ...] for each grid of input character pattern
+    def self.spatial_weight_filter map
+      #default grid should be 15
+      grid = map.size
+      new_grid = (grid / 2.0).ceil
+      new_map = Map.new(new_grid, new_grid, [0, 0, 0, 0])
+
+      (0..(grid - 1)).each_slice(2) do |i, i2|
+        (0..(grid - 1)).each_slice(2) do |j, j2|
+          #weights = [1/16, 2/16, 1/16];
+          #          [2/16, 4/16, 2/16];
+          #          [1/16, 2/16, 1/16]
+          w11 = (0..(grid-1)).cover?(i+1) && (0..(grid-1)).cover?(j-1)? map[i+1,j-1].map{|e| e * 1 / 16.0} : [0, 0, 0, 0]
+          w12 = (0..(grid-1)).cover?(i+1) && (0..(grid-1)).cover?(j)? map[i+1,j].map{|e| e * 2 / 16.0} : [0, 0, 0, 0]
+          w13 = (0..(grid-1)).cover?(i+1) && (0..(grid-1)).cover?(j+1)? map[i+1,j+1].map{|e| e * 1 / 16.0} : [0, 0, 0, 0]
+          w21 = (0..(grid-1)).cover?(i) && (0..(grid-1)).cover?(j-1)? map[i,j-1].map{|e| e * 2 / 16.0} : [0, 0, 0, 0]
+          w22 = (0..(grid-1)).cover?(i) && (0..(grid-1)).cover?(j)? map[i,j].map{|e| e * 4 / 16.0} : [0, 0, 0, 0]
+          w23 = (0..(grid-1)).cover?(i) && (0..(grid-1)).cover?(j+1)? map[i,j+1].map{|e| e * 2 / 16.0} : [0, 0, 0, 0]
+          w31 = (0..(grid-1)).cover?(i-1) && (0..(grid-1)).cover?(j-1)? map[i-1,j-1].map{|e| e * 1 / 16.0} : [0, 0, 0, 0]
+          w32 = (0..(grid-1)).cover?(i-1) && (0..(grid-1)).cover?(j)? map[i-1,j].map{|e| e * 2 / 16.0} : [0, 0, 0, 0]
+          w33 = (0..(grid-1)).cover?(i-1) && (0..(grid-1)).cover?(j+1)? map[i-1,j+1].map{|e| e * 1 / 16.0} : [0, 0, 0, 0]
+
+          new_map[i/2,j/2] = [w11[0] + w12[0] + w13[0] + w21[0] + w22[0] + w23[0] + w31[0] + w32[0] + w33[0],
+                              w11[1] + w12[1] + w13[1] + w21[1] + w22[1] + w23[1] + w31[1] + w32[1] + w33[1],
+                              w11[2] + w12[2] + w13[2] + w21[2] + w22[2] + w23[2] + w31[2] + w32[2] + w33[2],
+                              w11[3] + w12[3] + w13[3] + w21[3] + w22[3] + w23[3] + w31[3] + w32[3] + w33[3]]
+        end
+      end
+
+      new_map
+    end
+
+    #This method smooths a heatmap using spatial_weight_filter technique
+    #but instead of taking every 2nd grid, it processes every grid and stores the average of the weighted sum of adjacent grids
+    #Params:
+    #+map+:: a heatmap
+    def self.smooth_heatmap map
+      grid = map.size
+      #map is a heatmap
+      new_map = Map.new(grid, grid, 0)
+
+      (0..(grid - 1)).each do |i|
+        (0..(grid - 1)).each do |j|
+          #weights = [1/16, 2/16, 1/16];
+          #          [2/16, 4/16, 2/16];
+          #          [1/16, 2/16, 1/16]
+          w11 = (0..(grid-1)).cover?(i+1) && (0..(grid-1)).cover?(j-1)? map[i+1,j-1] * 1 / 16.0 : 0
+          w12 = (0..(grid-1)).cover?(i+1) && (0..(grid-1)).cover?(j)? map[i+1,j] * 2 / 16.0 : 0
+          w13 = (0..(grid-1)).cover?(i+1) && (0..(grid-1)).cover?(j+1)? map[i+1,j+1] * 1 / 16.0 : 0
+          w21 = (0..(grid-1)).cover?(i) && (0..(grid-1)).cover?(j-1)? map[i,j-1] * 2 / 16.0 : 0
+          w22 = (0..(grid-1)).cover?(i) && (0..(grid-1)).cover?(j)? map[i,j] * 4 / 16.0 : 0
+          w23 = (0..(grid-1)).cover?(i) && (0..(grid-1)).cover?(j+1)? map[i,j+1] * 2 / 16.0 : 0
+          w31 = (0..(grid-1)).cover?(i-1) && (0..(grid-1)).cover?(j-1)? map[i-1,j-1] * 1 / 16.0 : 0
+          w32 = (0..(grid-1)).cover?(i-1) && (0..(grid-1)).cover?(j)? map[i-1,j] * 2 / 16.0 : 0
+          w33 = (0..(grid-1)).cover?(i-1) && (0..(grid-1)).cover?(j+1)? map[i-1,j+1] * 1 / 16.0 : 0
+
+          new_map[i,j] = w11 + w12 + w13 + w21 + w22 + w23 + w31 + w32 + w33
+        end
+      end
+
+      new_map
+    end
+  end
+end

data/lib/kvg_character_recognition/preprocessor.rb

@@ -0,0 +1,214 @@
+module KvgCharacterRecognition
+  #This class has a collection of methods for the preprocessing step of character recognition
+  class Preprocessor
+
+    #A simple smooth method using the following formula
+    #p'(i) = (w(-M)*p(i-M) + ... + w(0)*p(i) + ... + w(M)*p(i+M)) / S
+    #where the smoothed point is a weighted average of its adjacent points.
+    #Only the user input should be smoothed, it is not necessary for kvg data.
+    #Params:
+    #+stroke+:: array of points i.e [[x1, y1], [x2, y2] ...]
+    def self.smooth stroke
+      weights = [1,3,1]
+      offset = weights.length / 2
+      wsum = weights.inject{ |sum, x|  sum + x}
+
+      return stroke if stroke.length < weights.length
+
+      copy = stroke.dup
+
+      (offset..(stroke.length - offset - 1)).each do |i|
+        accum = [0, 0]
+
+        weights.each_with_index do |w, j|
+          accum[0] += w * copy[i + j - offset][0]
+          accum[1] += w * copy[i + j - offset][1]
+        end
+
+        stroke[i] = accum.map{ |acc| (acc / wsum.to_f).round(2) }
+      end
+      stroke
+    end
+
+    #This method executes different preprocessing steps
+    #0.Normalize strokes to the size 109x109 and center the coordinates using bi moment normalization method
+    #1.Smooth strokes if set to true
+    #2.Interpolate points by given distance, in order to equalize the sample rate of input and template
+    #3.Downsample by given interval
+    def self.preprocess strokes, interpolate_distance=0.8, downsample_interval=4, smooth=true
+      means, diffs = means_and_diffs(strokes)
+      #normalize strokes
+      strokes = bi_moment_normalize(means, diffs, strokes)
+
+      strokes.map do |stroke|
+        stroke = smooth(stroke) if smooth
+        interpolated = interpolate(stroke, interpolate_distance)
+        downsample(interpolated, downsample_interval)
+      end
+    end
+
+    #This method calculates means and diffs of x and y coordinates in the strokes
+    #The return values are used in the normalization step
+    #means, diffs = means_and_diffs strokes
+    #Return values:
+    #+means+:: [mean_of_x, mean_of_y]
+    #+diffs+:: differences of the x and y coordinates to their means i.e. [[d_x1, d_x2 ...], [d_y1, d_y2 ...]]
+    def self.means_and_diffs strokes
+      points = strokes.flatten(1)
+      sums = points.inject([0, 0]){ |acc, point| acc = [acc[0] + point[0], acc[1] + point[1]] }
+      #means = [x_c, y_c]
+      means = sums.map{ |sum| (sum / points.length.to_f).round(2) }
+
+      diffs = points.inject([[], []]){ |acc, point| acc = [acc[0] << point[0] - means[0], acc[1] << point[1] - means[1]] }
+      [means, diffs]
+    end
+
+    #This methods normalizes the strokes using bi moment
+    #Params:
+    #+strokes+:: [[[x1, y1], [x2, y2], ...], [[x1, y1], ...]]
+    #+means+:: [x_c, y_c]
+    #+diffs+:: [d_x, d_y]; d_x = [d1, d2, ...]
+    def self.bi_moment_normalize means, diffs, strokes
+
+      #calculating delta values
+      delta = Proc.new do |diff, operator|
+        #d_x or d_y
+        #operator: >= or <
+        accum = 0
+        counter = 0
+
+        diff.each do |d|
+          if d.send operator, 0
+            accum += d ** 2
+            counter += 1
+          end
+        end
+        accum / counter
+      end
+
+      new_strokes = []
+      strokes.each do |stroke|
+        new_stroke = []
+        stroke.each do |point|
+          if point[0] - means[0] >= 0
+            new_x = ( CONFIG[:size] * (point[0] - means[0]) / (4 * Math.sqrt(delta.call(diffs[0], :>=))).round(2) ) + CONFIG[:size]/2
+          else
+            new_x = ( CONFIG[:size] * (point[0] - means[0]) / (4 * Math.sqrt(delta.call(diffs[0], :<))).round(2) ) + CONFIG[:size]/2
+          end
+          if point[1] - means[1] >= 0
+            new_y = ( CONFIG[:size] * (point[1] - means[1]) / (4 * Math.sqrt(delta.call(diffs[1], :>=))).round(2) ) + CONFIG[:size]/2
+          else
+            new_y = ( CONFIG[:size] * (point[1] - means[1]) / (4 * Math.sqrt(delta.call(diffs[1], :<))).round(2) ) + CONFIG[:size]/2
+          end
+
+          if new_x >= 0 && new_x <= CONFIG[:size] && new_y >= 0 && new_y <= CONFIG[:size]
+            new_stroke << [new_x.round(3), new_y.round(3)]
+          end
+        end
+        new_strokes << new_stroke unless new_stroke.empty?
+      end
+      new_strokes
+    end
+
+    #This method returns the significant points of a given character
+    #Significant points are:
+    #- Start and end point of a stroke
+    #- Point on curve or edge
+    #To determine whether a point is on curve or edge, we take the 2 adjacent points and calculate the angle between the 2 vectors
+    #If the angle is smaller than 150 degree, then the point should be on curve or edge
+    def self.significant_points strokes
+      points = []
+      strokes.each_with_index do |stroke, i|
+        points << stroke[0]
+
+        #collect edge points
+        #determine whether a point is an edge point by the internal angle between vector P_i-1 - P_i and P_i+1 - P_i
+        pre = stroke[0]
+        (1..(stroke.length - 1)).each do |j|
+          current = stroke[j]
+          nex = stroke[j+1]
+          if nex
+            v1 = [pre[0] - current[0], pre[1] - current[1]]
+            v2 = [nex[0] - current[0], nex[1] - current[1]]
+            det = v1[0] * v2[1] - (v2[0] * v1[1])
+            dot = v1[0] * v2[0] + (v2[1] * v1[1])
+            angle = Math.atan2(det, dot) / (Math::PI / 180)
+
+            if angle.abs < 150
+              #current point is on a curve or an edge
+              points << current
+            end
+          end
+          pre = current
+        end
+
+        points << stroke[stroke.length - 1]
+      end
+
+      points
+    end
+
+    #This methods calculates the euclidean distance between 2 points
+    #Params:
+    #- p1, p2: [x, y]
+    def self.euclidean_distance(p1, p2)
+      sum_of_squares = 0
+      p1.each_with_index do |p1_coord,index|
+        sum_of_squares += (p1_coord - p2[index]) ** 2
+      end
+      Math.sqrt( sum_of_squares )
+    end
+
+    #This method interpolates points into a stroke with given distance
+    #The algorithm is taken from the paper preprocessing techniques for online character recognition 
+    def self.interpolate stroke, d=0.5
+      current = stroke.first
+      new_stroke = [current]
+
+      index = 1
+      last_index = 0
+      while index < stroke.length do
+        point = stroke[index]
+
+        #only consider point with greater than d distance to current point
+        if euclidean_distance(current, point) < d
+          index += 1
+        else
+
+          #calculate new point coordinate
+          new_point = []
+          if point[0] == current[0] # x2 == x1
+            if point[1] > current[1] # y2 > y1
+              new_point = [current[0], current[1] + d]
+            else # y2 < y1
+              new_point = [current[0], current[1] - d]
+            end
+          else # x2 != x1
+            slope = (point[1] - current[1]) / (point[0] - current[0]).to_f
+            if point[0] > current[0] # x2 > x1
+              new_point[0] = current[0] + Math.sqrt(d**2 / (slope**2 + 1))
+            else # x2 < x1
+              new_point[0] = current[0] - Math.sqrt(d**2 / (slope**2 + 1))
+            end
+            new_point[1] = slope * new_point[0] + point[1] - (slope * point[0])
+          end
+
+          new_point = new_point.map{ |num| num.round(2) }
+          new_stroke << new_point
+
+          current = new_point
+          last_index += ((index - last_index) / 2).floor
+          index = last_index + 1
+        end
+      end
+
+      new_stroke
+    end
+
+    #This methods downsamples a stroke in given interval
+    #The number of points in the stroke will be reduced
+    def self.downsample stroke, interval=3
+      stroke.each_slice(interval).map(&:first)
+    end
+  end
+end

data/lib/kvg_character_recognition/recognizer.rb

@@ -0,0 +1,63 @@
+require 'matrix'
+module KvgCharacterRecognition
+  #This class contains methods calculating similarity scores between input pattern and template patterns
+  class Recognizer
+
+    #This method selects all templates from the database which should be further examined
+    #It filtered out those characters with a too great difference in number of strokes to the input character
+    def self.select_templates strokes
+      min = strokes.count <= 5 ? strokes.count : strokes.count - 5
+      max = strokes.count + 10
+      KvgCharacterRecognition.db[:characters].where(:number_of_strokes => (min..max))
+    end
+
+    #This method uses heatmap of significant points to coarse recognize the input pattern
+    #Params:
+    #+strokes+:: strokes should be preprocessed
+    def self.coarse_recognize strokes
+      heatmap = FeatureExtractor.heatmap(Preprocessor.significant_points(strokes), CONFIG[:significant_points_heatmap_grid], CONFIG[:size]).to_a
+
+      templates = select_templates strokes
+      templates.map do |candidate|
+        candidate_heatmap = candidate[:heatmap_significant_points].split(",").map(&:to_f)
+
+        score = Preprocessor.euclidean_distance(heatmap, candidate_heatmap)
+        [score.round(3), candidate]
+      end
+    end
+
+    #This method calculates similarity scores which is an average of the somehow weighted sum of the euclidean distance of
+    #1. 20x20 smoothed heatmap
+    #2. euclidean distance of directional feature densities in average
+    #Params:
+    #+strokes+:: strokes are not preprocessed
+    def self.scores strokes
+      #preprocess strokes
+      #with smoothing
+      strokes = Preprocessor.preprocess(strokes, CONFIG[:interpolate_distance], CONFIG[:downsample_interval], true)
+
+      #feature extraction
+      directions = Matrix.columns(FeatureExtractor.spatial_weight_filter(FeatureExtractor.directional_feature_densities(strokes, CONFIG[:direction_grid])).to_a).to_a
+      heatmap_smoothed = FeatureExtractor.smooth_heatmap(FeatureExtractor.heatmap(strokes.flatten(1), CONFIG[:smoothed_heatmap_grid], CONFIG[:size])).to_a
+
+      #dump half of the templates after coarse recognition
+      #collection is in the form [[score, c1], [score, c2] ...]
+      collection = coarse_recognize(strokes).sort{ |a, b| a[0] <=> b[0] }
+
+      scores = collection.take(collection.count / 2).map do |cand|
+        direction_score = (Preprocessor.euclidean_distance(directions[0], cand[1][:direction_e1].split(",").map(&:to_f)) +
+                           Preprocessor.euclidean_distance(directions[1], cand[1][:direction_e2].split(",").map(&:to_f)) +
+                           Preprocessor.euclidean_distance(directions[2], cand[1][:direction_e3].split(",").map(&:to_f)) +
+                           Preprocessor.euclidean_distance(directions[3], cand[1][:direction_e4].split(",").map(&:to_f)) ) / 4
+
+        heatmap_score = Preprocessor.euclidean_distance(heatmap_smoothed, cand[1][:heatmap_smoothed].split(",").map(&:to_f))
+
+        mix = (direction_score / 100) + heatmap_score
+        [mix/2, cand[1][:id], cand[1][:value]]
+      end
+
+      scores.sort{ |a, b| a[0] <=> b[0] }
+    end
+
+  end
+end

data/lib/kvg_character_recognition/utils.rb

@@ -0,0 +1,310 @@
+module KvgCharacterRecognition
+
+  #This class can be used for storing heatmap count and directional feature densities
+  #basically it is a nxm matrix with an initial value in each cell
+  class Map
+    #Make a new map with
+    #Params:
+    #+n+:: row length
+    #+m+:: column length
+    #+initial_value+:: for heatmap initial_value = 0 and for directional feature densities initial_value = [0, 0, 0, 0] <= [weight in e1, weight in e2, ...]
+    def initialize n, m, initial_value
+      @array = Array.new(n * m, initial_value)
+      @n = n
+      @m = m
+    end
+
+    #Access value in the cell of i-th row and j-th column
+    #e.g. map[i,j]
+    def [](i, j)
+      @array[j*@n + i]
+    end
+
+    #Store value in the cell of i-th row and j-th column
+    #e.g. map[i,j] = value
+    def []=(i, j, value)
+      @array[j*@n + i] = value
+    end
+
+    def to_a
+      @array
+    end
+
+    #Normaly n is the same as m
+    def size
+      @n
+    end
+  end
+
+
+  #This module contains classes which can be used to parse a svg command
+  #The code is copied from https://github.com/rogerbraun/KVG-Tools
+  #Methods for generating sexp or xml outputs are removed
+  module KvgParser
+    #A Point
+    class Point
+      attr_accessor :x, :y, :color
+
+      def initialize(x,y, color = :black)
+        @x,@y, @color = x, y, color
+      end
+
+      #Basic point arithmetics
+      def +(p2)
+        return Point.new(@x + p2.x, @y + p2.y)
+      end
+
+      def -(p2)
+        return Point.new(@x - p2.x, @y - p2.y)
+      end
+
+      def dist(p2)
+        return Math.sqrt((p2.x - @x)**2 + (p2.y - @y)**2)
+      end
+
+      def *(number)
+        return Point.new(@x * number, @y * number)
+      end
+
+      #to array
+      def to_a
+        [@x.round(2), @y.round(2)]
+      end
+
+    end
+
+    # SVG_M represents the moveto command. 
+    # SVG Syntax is:
+    # m x y
+    # It sets the current cursor to the point (x,y).
+    # As always, capitalization denotes absolute values.
+    # Takes a Point as argument.
+    # If given 2 Points, the second argument is treated as the current cursor.
+    class SVG_M
+
+      def initialize(p1, p2 = Point.new(0,0))
+        @p = p1 + p2
+      end
+
+      def to_points
+        return []
+      end
+
+      def current_cursor
+        return @p
+      end
+
+    end
+
+    # SVG_C represents the cubic Bézier curveto command. 
+    # Syntax is:
+    # c x1 y1 x2 y2 x y
+    # It sets the current cursor to the point (x,y).
+    # As always, capitalization denotes absolute values.
+    # Takes 4 Points as argument, the fourth being the current cursor
+    # If constructed using SVG_C.relative, the current cursor is added to every
+    # point.
+    class SVG_C
+
+      def initialize(c1,c2,p,current_cursor)
+        @c1,@c2,@p,@current_cursor = c1,c2,p,current_cursor
+        @@c_color = :green
+      end
+
+      def SVG_C.relative(c1,c2,p,current_cursor)
+        SVG_C.new(c1 + current_cursor, c2 + current_cursor, p + current_cursor, current_cursor)
+      end
+
+      def second_point
+        @c2
+      end
+
+      # This implements the algorithm found here:
+      # http://www.cubic.org/docs/bezier.htm
+      # Takes 2 Points and a factor between 0 and 1
+      def linear_interpolation(a,b,factor)
+
+        xr = a.x + ((b.x - a.x) * factor)
+        yr = a.y + ((b.y - a.y) * factor)
+
+        return Point.new(xr,yr);
+
+      end
+
+      def switch_color
+        if @@c_color == :green
+          @@c_color = :red
+        elsif @@c_color == :red
+          @@c_color = :purple
+        else
+          @@c_color = :green
+        end
+      end
+
+      def make_curvepoint(factor)
+        ab = linear_interpolation(@current_cursor,@c1,factor)
+        bc = linear_interpolation(@c1,@c2,factor)
+        cd = linear_interpolation(@c2,@p,factor)
+
+        abbc = linear_interpolation(ab,bc,factor)
+        bccd = linear_interpolation(bc,cd,factor)
+        return linear_interpolation(abbc,bccd,factor)
+      end
+
+      def length(points)
+        old_point = @current_cursor;
+        length = 0.0
+        factor = points.to_f
+
+        (1..points).each {|point|
+          new_point = make_curvepoint(point/(factor.to_f))
+          length += old_point.dist(new_point)
+          old_point = new_point
+        }
+        return length
+      end
+
+      # This gives back an array of points on the curve. The argument given
+      # denotes how the distance between each point.
+      def make_curvepoint_array(distance)
+        result = Array.new
+
+        l = length(20)
+        points = l * distance
+        factor = points.to_f
+
+        (0..points).each {|point|
+          result.push(make_curvepoint(point/(factor.to_f)))
+        }
+
+        return result
+      end
+
+
+      def to_points
+        return make_curvepoint_array(0.3)
+      end
+
+      def current_cursor
+        @p
+      end
+
+    end
+
+    # SVG_S represents the smooth curveto command. 
+    # Syntax is:
+    # s x2 y2 x y
+    # It sets the current cursor to the point (x,y).
+    # As always, capitalization denotes absolute values.
+    # Takes 3 Points as argument, the third being the current cursor
+    # If constructed using SVG_S.relative, the current cursor is added to every
+    # point.
+    class SVG_S < SVG_C
+
+      def initialize(c2, p, current_cursor,previous_point)
+        super(SVG_S.reflect(previous_point,current_cursor), c2, p, current_cursor)
+      end
+
+      # The reflection in this case is rather tricky. Using SVG_C.relative, the
+      # offset of current_cursor is added to all the positions (except current_cursor).
+      # The reflected point, however is already calculated in absolute values.
+      # Because of this, we have to subtract the current_cursor from the reflected 
+      # point, as it is already added later. I think I got the classes somewhat wrong.
+      # Maybe points should get a field whether they are absolute oder relative?
+      # Don't know yet. It works now, though!
+      def SVG_S.relative(c2, p, current_cursor, previous_point)
+        SVG_C.relative(SVG_S.reflect(previous_point,current_cursor) - current_cursor, c2, p, current_cursor)
+      end
+
+      def SVG_S.reflect(p, mirror)
+        return mirror + (mirror - p)
+      end
+
+    end
+
+
+    # Stroke represent one stroke, which is a series of SVG commands.
+    class Stroke
+      COMMANDS = ["M", "C", "c", "s", "S"]
+
+      def initialize(stroke_as_code)
+        @command_list = parse(stroke_as_code) 
+      end
+
+      def to_points
+        return @command_list.map{|element| element.to_points}.flatten
+      end
+
+      #to array
+      #TODO: better implementation using composite pattern
+      def to_a
+        to_points.map{|point| point.to_a}
+      end
+
+      def split_elements(line)
+        # This is magic.
+        return line.gsub("-",",-").gsub("s",",s,").gsub("S",",S,").gsub("c",",c,").gsub("C",",C,").gsub("m", "M").gsub("M","M,").gsub("[","").gsub(";",",;,").gsub(",,",",").gsub(" ,", ",").gsub(", ", ",").gsub(" ", ",").split(/,/);
+      end
+
+      def parse(stroke_as_code)
+        elements = split_elements(stroke_as_code).delete_if{ |e| e == "" }  
+        command_list = Array.new
+        current_cursor = Point.new(0,0);
+
+        while elements != [] do
+
+          case elements.slice!(0)
+          when "M"
+            x,y = elements.slice!(0..1)
+            m = SVG_M.new(Point.new(x.to_f,y.to_f))
+            current_cursor = m.current_cursor
+            command_list.push(m)
+
+          when "C"
+            x1,y1,x2,y2,x,y = elements.slice!(0..5)
+            c = SVG_C.new(Point.new(x1.to_f,y1.to_f), Point.new(x2.to_f,y2.to_f), Point.new(x.to_f,y.to_f), current_cursor)
+            current_cursor = c.current_cursor
+            command_list.push(c)
+
+            #handle polybezier
+            unless elements.empty? || COMMANDS.include?(elements.first)
+              elements.unshift("C")
+            end
+          when "c"
+            x1,y1,x2,y2,x,y = elements.slice!(0..5)
+            c = SVG_C.relative(Point.new(x1.to_f,y1.to_f), Point.new(x2.to_f,y2.to_f), Point.new(x.to_f,y.to_f), current_cursor)
+            current_cursor = c.current_cursor
+            command_list.push(c)
+
+            #handle polybezier
+            unless elements.empty? || COMMANDS.include?(elements.first)
+              elements.unshift("c")
+            end
+
+          when "s"
+            x2,y2,x,y = elements.slice!(0..3)
+            reflected_point = command_list[-1].second_point
+            s = SVG_S.relative(Point.new(x2.to_f,y2.to_f), Point.new(x.to_f,y.to_f), current_cursor, reflected_point)
+            current_cursor = s.current_cursor
+            command_list.push(s)
+
+          when "S"
+            x2,y2,x,y = elements.slice!(0..3)
+            reflected_point = command_list[-1].second_point
+            s = SVG_S.new(Point.new(x2.to_f,y2.to_f), Point.new(x.to_f,y.to_f), current_cursor,reflected_point)
+            current_cursor = s.current_cursor
+            command_list.push(s)
+
+          else
+            #print "You should not be here\n"
+
+          end
+
+        end
+
+        return command_list
+      end
+
+    end
+  end
+end

data/lib/kvg_character_recognition/version.rb

@@ -0,0 +1,3 @@
+module KvgCharacterRecognition
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: kvg_character_recognition
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jiayi Zheng
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "This gem contains a CJK-character recognition engine using pattern/template
+  matching techniques.\n  It can recognize stroke-order and stroke-number free handwritten
+  character patterns in the format [stroke1, stroke2 ...].\n  A stroke is an array
+  of points in the format [[x1, y1], [x2, y2], ...].\n  KanjiVG data(characters in
+  svg format) from https://github.com/KanjiVG/kanjivg/releases are used as templates.\n
+  \ "
+email:
+- thebluber@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- kvg_character_recognition.gemspec
+- lib/kvg_character_recognition.rb
+- lib/kvg_character_recognition/database.rb
+- lib/kvg_character_recognition/feature_extractor.rb
+- lib/kvg_character_recognition/preprocessor.rb
+- lib/kvg_character_recognition/recognizer.rb
+- lib/kvg_character_recognition/utils.rb
+- lib/kvg_character_recognition/version.rb
+homepage: https://github.com/thebluber/kvg_character_recognition
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: CJK-character recognition using template matching techniques and template
+  data from KanjiVG project
+test_files: []