kvg_character_recognition 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d60d7f44902345773b5fff377783a490a41c7f06
-  data.tar.gz: 6b8e90de99d64c80ce576f969114cd02432fea58
+  metadata.gz: 3561d546950211fe53ebcb63610de390341134c8
+  data.tar.gz: 0e96434c9cb5e5d724bec72b4c0046d055b6c7e5
 SHA512:
-  metadata.gz: 0ae3dda7c2114311a4613ed39b6e48e2e13a4b51619fb791c9476a0070a0dd49e60468fd63d7a7cb660ea52ea803e05cef48fbdd61f0c7a23c5c74141a54fc47
-  data.tar.gz: 6c43c6da5be2c25b6cf75ed364de496f8f87fb6f9bc0d8e2aaa0161e0e0ac159d2bdcf8805a36ff77f0ec52eab85fee697a093635a530dbfd779e7163f00f029
+  metadata.gz: 3129719a4702919436175246fa579ac3f28638fc49fc897941f5dfbba8f13cb820904058e194427791898411af5d46e4bf875a9acedebcc81478fac7110a7227
+  data.tar.gz: dff06615f6bedfac5bd6521572a5f367462f1fed073c6b4809a818b13f3b1ffb36a58361668b132d3e432861b6c0c56532852ce079eb27c3ccc709305ace8143

data/kvg_character_recognition.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
     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 == 'kvg_character_recognition-0.1.2.gem' || f.match(%r{^(test|spec|features)/}) }
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f == 'kvg_character_recognition-0.1.3.gem' || f.match(%r{^(test|spec|features)/}) }
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]

data/lib/kvg_character_recognition.rb

@@ -1,35 +1,22 @@
-require 'bundler'
-Bundler.require
+require 'nokogiri'
 require 'yaml'
+require 'json'
+require 'matrix'
 #require all files in ./lib/
-Dir[File.join(File.dirname(__FILE__), '/kvg_character_recognition/*.rb')].each {|file| require file }
+require File.join(File.dirname(__FILE__), '/kvg_character_recognition/utils.rb')
+require File.join(File.dirname(__FILE__), '/kvg_character_recognition/normalization.rb')
+require File.join(File.dirname(__FILE__), '/kvg_character_recognition/preprocessor.rb')
+require File.join(File.dirname(__FILE__), '/kvg_character_recognition/non_structural_feature.rb')
+require File.join(File.dirname(__FILE__), '/kvg_character_recognition/heatmap_feature.rb')
+require File.join(File.dirname(__FILE__), '/kvg_character_recognition/kvg_parser.rb')
+require File.join(File.dirname(__FILE__), '/kvg_character_recognition/datastore.rb')
+require File.join(File.dirname(__FILE__), '/kvg_character_recognition/trainer.rb')
+require File.join(File.dirname(__FILE__), '/kvg_character_recognition/template.rb')
+require File.join(File.dirname(__FILE__), '/kvg_character_recognition/recognizer.rb')
 
 module KvgCharacterRecognition
-
-  CONFIG = {
-    size: 109, #fixed canvas size of kanjivg data
-    downsample_interval: 4,
-    interpolate_distance: 0.8,
-    heatmap_coarse_grid: 17,
-    heatmap_granular_grid: 17,
-  }
-  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)
+  def self.init_datastore filename="characters.json", xml="kanjivg-20150615-2.xml"
+    datastore = JSONDatastore.new(filename)
+    Template.parse_from_xml xml, datastore
   end
 end

data/lib/kvg_character_recognition/datastore.rb

@@ -1,5 +1,3 @@
-require 'json'
-
 module KvgCharacterRecognition
   class JSONDatastore
     def initialize filename = 'characters.json'

data/lib/kvg_character_recognition/heatmap_feature.rb

@@ -0,0 +1,50 @@
+module KvgCharacterRecognition
+  class HeatmapFeature
+    include NonStructuralFeature
+    attr_accessor :size, :weights, :number_of_grids, :heatmaps
+    def initialize bi_normed, ld_normed, pd_normed, size, number_of_grids, weights=[1/9.0, 1/9.0, 1/9.0, 1/9.0, 1/9.0, 1/9.0, 1/9.0, 1/9.0, 1/9.0]
+      @size = size
+      @number_of_grids = number_of_grids
+      @number_of_points = bi_normed.flatten(1).count
+      @weights = weights
+      @heatmaps = smooth(generate_heatmaps(bi_normed, ld_normed, pd_normed))
+    end
+
+    def generate_heatmaps bi_normed, ld_normed, pd_normed
+
+      grid_size = size / @number_of_grids.to_f
+
+      map = Map.new @number_of_grids, @number_of_grids, [0, 0, 0]
+
+      #fill the heatmap
+      bi_normed.each do |stroke|
+        stroke.each do |point|
+          grid1 = [(point[0] / grid_size).floor, (point[1] / grid_size).floor]
+
+          map[grid1[0], grid1[1]] = [map[grid1[0], grid1[1]][0] + (1 / @number_of_points.to_f).round(4),
+                                     map[grid1[0], grid1[1]][1],
+                                     map[grid1[0], grid1[1]][2]] if grid1[0] < @number_of_grids && grid1[1] < @number_of_grids
+        end
+      end
+      ld_normed.each do |stroke|
+        stroke.each do |point|
+          grid2 = [(point[0] / grid_size).floor, (point[1] / grid_size).floor]
+
+          map[grid2[0], grid2[1]] = [map[grid2[0], grid2[1]][0],
+                                     map[grid2[0], grid2[1]][1] + (1 / @number_of_points.to_f).round(4),
+                                     map[grid2[0], grid2[1]][2]] if grid2[0] < @number_of_grids && grid2[1] < @number_of_grids
+        end
+      end
+      pd_normed.each do |stroke|
+        stroke.each do |point|
+          grid4 = [(point[0] / grid_size).floor, (point[1] / grid_size).floor]
+
+          map[grid4[0], grid4[1]] = [map[grid4[0], grid4[1]][0],
+                                     map[grid4[0], grid4[1]][1],
+                                     map[grid4[0], grid4[1]][2] + (1 / @number_of_points.to_f).round(4)] if grid4[0] < @number_of_grids && grid4[1] < @number_of_grids
+        end
+      end
+      map
+    end
+  end
+end

data/lib/kvg_character_recognition/kvg_parser.rb

@@ -0,0 +1,272 @@
+module KvgCharacterRecognition
+  #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/non_structural_feature.rb

@@ -0,0 +1,72 @@
+module NonStructuralFeature
+  #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
+    attr_accessor :initial_value
+    #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
+      @initial_value = initial_value
+    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
+
+  def smooth map
+    new_map = Map.new(@number_of_grids, @number_of_grids, map.initial_value)
+
+    (0..(@number_of_grids - 1)).each do |i|
+      (0..(@number_of_grids - 1)).each do |j|
+        #weights alternative 
+        #        = [1/16, 2/16, 1/16];
+        #          [2/16, 4/16, 2/16];
+        #          [1/16, 2/16, 1/16]
+        #
+        #weights = [1/9, 1/9, 1/9];
+        #          [1/9, 1/9, 1/9];
+        #          [1/9, 1/9, 1/9]
+        #
+        w11 = (0..(@number_of_grids-1)).cover?(i+1) && (0..(@number_of_grids-1)).cover?(j-1)? map[i+1,j-1].map{|e| e * @weights[0]} : [0, 0, 0]
+        w12 = (0..(@number_of_grids-1)).cover?(i+1) && (0..(@number_of_grids-1)).cover?(j)? map[i+1,j].map{|e| e * @weights[1]} : [0, 0, 0]
+        w13 = (0..(@number_of_grids-1)).cover?(i+1) && (0..(@number_of_grids-1)).cover?(j+1)? map[i+1,j+1].map{|e| e * @weights[2]} : [0, 0, 0]
+        w21 = (0..(@number_of_grids-1)).cover?(i) && (0..(@number_of_grids-1)).cover?(j-1)? map[i,j-1].map{|e| e * @weights[3]} : [0, 0, 0]
+        w22 = (0..(@number_of_grids-1)).cover?(i) && (0..(@number_of_grids-1)).cover?(j)? map[i,j].map{|e| e * @weights[4]} : [0, 0, 0]
+        w23 = (0..(@number_of_grids-1)).cover?(i) && (0..(@number_of_grids-1)).cover?(j+1)? map[i,j+1].map{|e| e * @weights[5]} : [0, 0, 0]
+        w31 = (0..(@number_of_grids-1)).cover?(i-1) && (0..(@number_of_grids-1)).cover?(j-1)? map[i-1,j-1].map{|e| e * @weights[6]} : [0, 0, 0]
+        w32 = (0..(@number_of_grids-1)).cover?(i-1) && (0..(@number_of_grids-1)).cover?(j)? map[i-1,j].map{|e| e * @weights[7]} : [0, 0, 0]
+        w33 = (0..(@number_of_grids-1)).cover?(i-1) && (0..(@number_of_grids-1)).cover?(j+1)? map[i-1,j+1].map{|e| e * @weights[8]} : [0, 0, 0]
+
+        new_map[i,j] = [(w11[0] + w12[0] + w13[0] + w21[0] + w22[0] + w23[0] + w31[0] + w32[0] + w33[0]).round(3),
+                        (w11[1] + w12[1] + w13[1] + w21[1] + w22[1] + w23[1] + w31[1] + w32[1] + w33[1]).round(3),
+                        (w11[2] + w12[2] + w13[2] + w21[2] + w22[2] + w23[2] + w31[2] + w32[2] + w33[2]).round(3)]
+      end
+    end
+
+    new_map
+  end
+end