kvg_character_recognition 0.1.3 → 0.2.0

data/lib/kvg_character_recognition/recognizer.rb

@@ -1,37 +1,35 @@
-require 'matrix'
 module KvgCharacterRecognition
   #This class contains methods calculating similarity scores between input pattern and template patterns
   module Recognizer
+    extend KvgCharacterRecognition::Trainer
 
     #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 points and strokes to the input character
-    def self.select_templates character, datastore
-      p_min = character.number_of_points - 100
-      p_max = character.number_of_points + 100
-      s_min = character.number_of_strokes - 12
-      s_max = character.number_of_strokes + 12
+    def self.select_templates datastore, number_of_points, number_of_strokes
+      p_min = number_of_points - 100
+      p_max = number_of_points + 100
+      s_min = number_of_strokes - 12
+      s_max = number_of_strokes + 12
       datastore.characters_in_range(p_min..p_max, s_min..s_max)
     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
+    #1. 17x17 smoothed heatmap
+    #2. manhattan distance of directional feature densities in average
     #Params:
     #+strokes+:: strokes are not preprocessed
     #+datastore+:: JSONDatastore or custom datastore type having method characters_in_stroke_range(min..max)
     def self.scores strokes, datastore
-      character = Trainer::Character.new(strokes, nil)
-      templates = select_templates character, datastore
+      strokes = preprocess(strokes)
+      heatmaps = heatmaps(strokes)
+      templates = select_templates datastore, @number_of_points, strokes.count
 
+      #scores = datastore.data.map do |cand|
       scores = templates.map do |cand|
-
-        heatmap_bi_moment_score = Math.manhattan_distance(cand[:heatmap_smoothed_granular], character.heatmap_smoothed_granular)
-        heatmap_line_density_score = Math.manhattan_distance(cand[:heatmap_smoothed_coarse], character.heatmap_smoothed_coarse)
-        heatmap_bi_moment_slant_score = Math.manhattan_distance(cand[:heatmap_smoothed_granular_with_slant], character.heatmap_smoothed_granular_with_slant)
-        heatmap_line_density_slant_score = Math.manhattan_distance(cand[:heatmap_smoothed_coarse_with_slant], character.heatmap_smoothed_coarse_with_slant)
-
-
-        [[heatmap_bi_moment_score, heatmap_line_density_score, heatmap_bi_moment_slant_score, heatmap_line_density_slant_score].min, cand]
+        score = Math.manhattan_distance(heatmaps[0], cand[:heatmaps][0]) +
+                Math.manhattan_distance(heatmaps[1], cand[:heatmaps][1]) +
+                Math.manhattan_distance(heatmaps[2], cand[:heatmaps][2])
+        [score, cand]
       end
 
       scores.sort{ |a, b| a[0] <=> b[0] }

data/lib/kvg_character_recognition/template.rb

@@ -0,0 +1,43 @@
+module KvgCharacterRecognition
+  class Template
+    extend KvgCharacterRecognition::Trainer
+    #This method populates the datastore 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
+    #+datastore+:: JSONDatastore or custom datastore type having methods store, persist!
+    def self.parse_from_xml xml, datastore, kanji_list=[]
+      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]
+        value = [codepoint.hex].pack("U")
+        if kanji_list.empty?
+          next unless codepoint.hex >= "04e00".hex && codepoint.hex <= "09faf".hex
+        else
+          next unless codepoint.hex >= "04e00".hex && codepoint.hex <= "09faf".hex && kanji_list.include?(value)
+        end
+        puts "#{codepoint} #{value}"
+
+        # parse strokes
+        strokes = kanji.xpath("g//path").map{|p| p.attributes["d"].value }.map{ |stroke| KvgCharacterRecognition::KvgParser::Stroke.new(stroke).to_a }
+
+        strokes = preprocess(strokes)
+
+        #Store to database
+        #--------------
+        character = {
+          value: value,
+          codepoint: codepoint.hex,
+          number_of_strokes: strokes.count,
+          number_of_points: @number_of_points,
+          heatmaps: heatmaps(strokes)
+        }
+
+        datastore.store character
+      end
+
+      datastore.persist!
+    end
+  end
+end

data/lib/kvg_character_recognition/trainer.rb

@@ -1,81 +1,58 @@
 module KvgCharacterRecognition
   module Trainer
-    class Character
-      attr_accessor :value,
-        :number_of_strokes,
-        :number_of_points,
-        :strokes,
-        :line_density_preprocessed_strokes,
-        :line_density_preprocessed_strokes_with_slant,
-        :bi_moment_preprocessed_strokes,
-        :bi_moment_preprocessed_strokes_with_slant,
-        :heatmap_smoothed_coarse,
-        :heatmap_smoothed_granular,
-        :heatmap_smoothed_coarse_with_slant,
-        :heatmap_smoothed_granular_with_slant
-      def initialize strokes, value
-        @value = value
-        @strokes = strokes
-        @number_of_strokes = @strokes.count
-        smooth = @value ? false : true
-        bi_moment_normalized_strokes, bi_moment_normalized_strokes_with_slant = Preprocessor.bi_moment_normalize(@strokes)
-        @bi_moment_preprocessed_strokes = Preprocessor.preprocess(bi_moment_normalized_strokes, CONFIG[:interpolate_distance], CONFIG[:downsample_interval], smooth)
-        @bi_moment_preprocessed_strokes_with_slant = Preprocessor.preprocess(bi_moment_normalized_strokes_with_slant, CONFIG[:interpolate_distance], CONFIG[:downsample_interval], smooth)
-
-        @number_of_points = @bi_moment_preprocessed_strokes.flatten(1).count
-
-        line_density_normalized_strokes = Preprocessor.line_density_normalize(@bi_moment_preprocessed_strokes)
-        @line_density_preprocessed_strokes = Preprocessor.preprocess(line_density_normalized_strokes, CONFIG[:interpolate_distance], CONFIG[:downsample_interval], true)
-        line_density_normalized_strokes_with_slant = Preprocessor.line_density_normalize(@bi_moment_preprocessed_strokes_with_slant)
-        @line_density_preprocessed_strokes_with_slant = Preprocessor.preprocess(line_density_normalized_strokes_with_slant, CONFIG[:interpolate_distance], CONFIG[:downsample_interval], true)
-
-        @heatmap_smoothed_coarse = Preprocessor.smooth_heatmap(Preprocessor.heatmap(@line_density_preprocessed_strokes.flatten(1), CONFIG[:heatmap_coarse_grid], CONFIG[:size])).to_a
-        @heatmap_smoothed_granular = Preprocessor.smooth_heatmap(Preprocessor.heatmap(@bi_moment_preprocessed_strokes.flatten(1), CONFIG[:heatmap_granular_grid], CONFIG[:size])).to_a
-
-        @heatmap_smoothed_coarse_with_slant = Preprocessor.smooth_heatmap(Preprocessor.heatmap(@line_density_preprocessed_strokes_with_slant.flatten(1), CONFIG[:heatmap_coarse_grid], CONFIG[:size])).to_a
-        @heatmap_smoothed_granular_with_slant = Preprocessor.smooth_heatmap(Preprocessor.heatmap(@bi_moment_preprocessed_strokes_with_slant.flatten(1), CONFIG[:heatmap_granular_grid], CONFIG[:size])).to_a
-
-      end
+    @@config = { downsample_rate: 4,
+                 interpolate_distance: 0.8,
+                 size: 109,
+                 smooth: true,
+                 smooth_weights: [1,2,3,2,1],
+                 smooth_filter_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],
+                 heatmap_number_of_grids: 17
+    }
+    @@preprocessor = Preprocessor.new(@@config[:interpolate_distance],
+                                      @@config[:size],
+                                      @@config[:smooth],
+                                      @@config[:smooth_weights])
+
+    # this variable will be set in the method preprocess
+    @number_of_points = 0
+
+    # preprocess strokes and set the number_of_points variable
+    # !the preprocessed strokes are not downsampled
+    def preprocess strokes
+      strokes = @@preprocessor.preprocess(strokes)
+      @number_of_points = strokes.flatten(1).count
+      strokes
     end
 
-    #This method populates the datastore 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
-    #+datastore+:: JSONDatastore or custom datastore type having methods store, persist!
-    def self.populate_from_xml xml, datastore
-      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 }
-
-        chr = Character.new strokes, value
-
-        #Store to database
-        #--------------
-        character = {
-          value: value,
-          codepoint: codepoint.hex,
-          number_of_strokes: strokes.count,
-          number_of_points: chr.number_of_points,
-          heatmap_smoothed_coarse: chr.heatmap_smoothed_coarse,
-          heatmap_smoothed_granular: chr.heatmap_smoothed_granular,
-          heatmap_smoothed_coarse_with_slant: chr.heatmap_smoothed_coarse_with_slant,
-          heatmap_smoothed_granular_with_slant: chr.heatmap_smoothed_granular_with_slant
-        }
-
-        datastore.store character
-      end
+    # This method returns the 3x 17x17 direction feature vector
+    # strokes are preprocessed
+    def heatmaps strokes
+      weights = @@config[:smooth_filter_weights]
+      number_of_grids = @@config[:heatmap_number_of_grids]
+
+      bi_normed = strokes
+      ld_normed = @@preprocessor.line_density_normalize(bi_normed).map{ |stroke| downsample(stroke, @@config[:downsample_rate]) }
+      pd_normed = @@preprocessor.point_density_normalize(bi_normed).map{ |stroke| downsample(stroke, @@config[:downsample_rate]) }
+      bi_normed = bi_normed.map{ |stroke| downsample(stroke, @@config[:downsample_rate]) }
+
+      # feature extraction
+      heatmaps_map = HeatmapFeature.new(bi_normed,
+                                        ld_normed,
+                                        pd_normed,
+                                        @@config[:size],
+                                        number_of_grids,
+                                        weights).heatmaps
+
+      # convert to feature vector
+      Matrix.columns(heatmaps_map.to_a).to_a
+    end
 
-      datastore.persist!
+    private
+    #This methods downsamples a stroke in given interval
+    #The number of points in the stroke will be reduced
+    def downsample stroke, interval
+      stroke.each_slice(interval).map(&:first)
     end
+
   end
 end

data/lib/kvg_character_recognition/utils.rb

@@ -19,314 +19,3 @@ module Math
     sum
   end
 end
-
-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