kvg_character_recognition 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f5bd00df050f48f3ee955daaa966fd04b10a5f3
-  data.tar.gz: bb45a8db8023fb37f4f929a673f1f811756540fa
+  metadata.gz: d60d7f44902345773b5fff377783a490a41c7f06
+  data.tar.gz: 6b8e90de99d64c80ce576f969114cd02432fea58
 SHA512:
-  metadata.gz: ae3a13b9370276c1714f19acebcf856cff091c27725514ae8f0a75f43ef754576d46bc69b7804d1203db5216524d0841e82b2deac7f29729ad5ebfe55441d080
-  data.tar.gz: 057e9896548709b6fd4187ffcf8d576b2d49fa0fb19f6b1cc3909e75befde49149aa934d54ea9c6bbab48d394f4fdf708404287ec6eae6857dab3b53b7a09650
+  metadata.gz: 0ae3dda7c2114311a4613ed39b6e48e2e13a4b51619fb791c9476a0070a0dd49e60468fd63d7a7cb660ea52ea803e05cef48fbdd61f0c7a23c5c74141a54fc47
+  data.tar.gz: 6c43c6da5be2c25b6cf75ed364de496f8f87fb6f9bc0d8e2aaa0161e0e0ac159d2bdcf8805a36ff77f0ec52eab85fee697a093635a530dbfd779e7163f00f029

data/kvg_character_recognition.gemspec

@@ -26,12 +26,11 @@ 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.1.gem' || f.match(%r{^(test|spec|features)/}) }
+  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.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "parallel"
   spec.add_dependency "nokogiri"
   spec.add_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/kvg_character_recognition.rb

@@ -10,9 +10,8 @@ module KvgCharacterRecognition
     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
+    heatmap_coarse_grid: 17,
+    heatmap_granular_grid: 17,
   }
   VALID_KEYS = CONFIG.keys
 

data/lib/kvg_character_recognition/datastore.rb

@@ -16,8 +16,8 @@ module KvgCharacterRecognition
       end
     end
 
-    def characters_in_stroke_range range
-      @data.select { |character| range === character[:number_of_strokes] }
+    def characters_in_range point_range, stroke_range
+      @data.select { |character| point_range === character[:number_of_points] && stroke_range === character[:number_of_strokes] }
     end
 
     def store character

data/lib/kvg_character_recognition/preprocessor.rb

@@ -9,7 +9,7 @@ module KvgCharacterRecognition
     #Params:
     #+stroke+:: array of points i.e [[x1, y1], [x2, y2] ...]
     def self.smooth stroke
-      weights = [1,3,1]
+      weights = [1,1,2,1,1]
       offset = weights.length / 2
       wsum = weights.inject{ |sum, x|  sum + x}
 
@@ -31,22 +31,44 @@ module KvgCharacterRecognition
     end
 
     #This method executes different preprocessing steps
-    #0.Normalize strokes to the size 109x109 and center the coordinates using bi moment normalization method
+    #strokes are normalized
     #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)
+        interpolated = smooth(interpolate(stroke, interpolate_distance))
         downsample(interpolated, downsample_interval)
       end
     end
 
+    # accumulated histogram needed by line density normalization
+    def self.accumulated_histogram points
+      grids = CONFIG[:size] + 1
+      h_x = []
+      h_y = []
+      (0..grids).each do |i|
+        h_x[i] = points.count{ |p| p[0].round == i }
+        h_y[i] = points.count{ |p| p[1].round == i }
+        h_x[i] = h_x[i] + h_x[i - 1] if i > 0
+        h_y[i] = h_y[i] + h_y[i - 1] if i > 0
+      end
+
+      [h_x, h_y]
+    end
+
+    # line density normalization
+    def self.line_density_normalize strokes
+      points = strokes.flatten(1)
+      h_x, h_y = accumulated_histogram points
+      strokes.map do |stroke|
+        stroke.map do |point|
+          [(CONFIG[:size] * h_x[point[0].round] / points.length.to_f).round(2), (CONFIG[:size] * h_y[point[1].round] / points.length.to_f).round(2)]
+        end
+      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
@@ -59,16 +81,28 @@ module KvgCharacterRecognition
       #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]
+      #for slant correction
+      diff_x = []
+      diff_y = []
+      u11 = 0
+      u02 = 0
+      points.each do |point|
+        diff_x << point[0] - means[0]
+        diff_y << point[1] - means[1]
+
+        u11 += (point[0] - means[0]) * (point[1] - means[1])
+        u02 += (point[1] - means[1])**2
+      end
+      [means, [diff_x, diff_y], -1 * u11 / u02]
     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
+    #+slant_correction+:: boolean whether a slant correction should be performed
+    #returns normed_strokes, normed_strokes_with_slant_correction
+    def self.bi_moment_normalize strokes
+      means, diffs, slant_slope = means_and_diffs strokes
 
       #calculating delta values
       delta = Proc.new do |diff, operator|
@@ -87,65 +121,44 @@ module KvgCharacterRecognition
       end
 
       new_strokes = []
+      new_strokes_with_slant = []
+
       strokes.each do |stroke|
         new_stroke = []
+        new_stroke_slant = []
         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
+          x = point[0]
+          y = point[1]
+          x_slant = x + (y - means[1]) * slant_slope
+
+          if x - means[0] >= 0
+            new_x = ( CONFIG[:size] * (x - 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
+            new_x = ( CONFIG[:size] * (x - 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
+          if x_slant - means[0] >= 0
+            new_x_slant = ( CONFIG[:size] * (x_slant - means[0]) / (4 * Math.sqrt(delta.call(diffs[0], :>=))).round(2) ) + CONFIG[:size]/2
+          else
+            new_x_slant = ( CONFIG[:size] * (x_slant - means[0]) / (4 * Math.sqrt(delta.call(diffs[0], :<))).round(2) ) + CONFIG[:size]/2
+          end
+
+          if y - means[1] >= 0
+            new_y = ( CONFIG[:size] * (y - 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
+            new_y = ( CONFIG[:size] * (y - 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
+          if new_x_slant >= 0 && new_x_slant <= CONFIG[:size] && new_y >= 0 && new_y <= CONFIG[:size]
+            new_stroke_slant << [new_x_slant.round(3), new_y.round(3)]
           end
-          pre = current
         end
-
-        points << stroke[stroke.length - 1]
+        new_strokes << new_stroke unless new_stroke.empty?
+        new_strokes_with_slant << new_stroke_slant unless new_stroke_slant.empty?
       end
-
-      points
+      [new_strokes, new_strokes_with_slant]
     end
 
     #This method interpolates points into a stroke with given distance
@@ -166,7 +179,7 @@ module KvgCharacterRecognition
 
           #calculate new point coordinate
           new_point = []
-          if point[0] == current[0] # x2 == x1
+          if point[0].round(2) == current[0].round(2) # x2 == x1
             if point[1] > current[1] # y2 > y1
               new_point = [current[0], current[1] + d]
             else # y2 < y1
@@ -183,9 +196,11 @@ module KvgCharacterRecognition
           end
 
           new_point = new_point.map{ |num| num.round(2) }
-          new_stroke << new_point
+          if current != new_point
+            new_stroke << new_point
 
-          current = new_point
+            current = new_point
+          end
           last_index += ((index - last_index) / 2).floor
           index = last_index + 1
         end
@@ -199,5 +214,67 @@ module KvgCharacterRecognition
     def self.downsample stroke, interval=3
       stroke.each_slice(interval).map(&:first)
     end
+
+    #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] += (1 / points.length.to_f).round(4)
+        end
+      end
+
+      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 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..(grid-1)).cover?(i+1) && (0..(grid-1)).cover?(j-1)? map[i+1,j-1] * 1 / 9.0 : 0
+          w12 = (0..(grid-1)).cover?(i+1) && (0..(grid-1)).cover?(j)? map[i+1,j] * 1 / 9.0 : 0
+          w13 = (0..(grid-1)).cover?(i+1) && (0..(grid-1)).cover?(j+1)? map[i+1,j+1] * 1 / 9.0 : 0
+          w21 = (0..(grid-1)).cover?(i) && (0..(grid-1)).cover?(j-1)? map[i,j-1] * 1 / 9.0 : 0
+          w22 = (0..(grid-1)).cover?(i) && (0..(grid-1)).cover?(j)? map[i,j] * 1 / 9.0 : 0
+          w23 = (0..(grid-1)).cover?(i) && (0..(grid-1)).cover?(j+1)? map[i,j+1] * 1 / 9.0 : 0
+          w31 = (0..(grid-1)).cover?(i-1) && (0..(grid-1)).cover?(j-1)? map[i-1,j-1] * 1 / 9.0 : 0
+          w32 = (0..(grid-1)).cover?(i-1) && (0..(grid-1)).cover?(j)? map[i-1,j] * 1 / 9.0 : 0
+          w33 = (0..(grid-1)).cover?(i-1) && (0..(grid-1)).cover?(j+1)? map[i-1,j+1] * 1 / 9.0 : 0
+
+          new_map[i,j] = (w11 + w12 + w13 + w21 + w22 + w23 + w31 + w32 + w33).round(4)
+        end
+      end
+
+      new_map
+    end
   end
 end

data/lib/kvg_character_recognition/recognizer.rb

@@ -1,34 +1,16 @@
 require 'matrix'
-require 'parallel'
 module KvgCharacterRecognition
   #This class contains methods calculating similarity scores between input pattern and template patterns
   module Recognizer
-    @thread_count = 10
 
     #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, datastore
-      min = strokes.count <= 5 ? strokes.count : strokes.count - 5
-      max = strokes.count + 10
-      datastore.characters_in_stroke_range(min..max)
-    end
-
-    #This method uses heatmap of significant points to coarse recognize the input pattern
-    #Params:
-    #+strokes+:: strokes should be preprocessed
-    #+datastore+:: JSONDatastore or custom datastore type having method characters_in_stroke_range(min..max)
-    def self.coarse_recognize strokes, datastore
-      heatmap = FeatureExtractor.heatmap(Preprocessor.significant_points(strokes), CONFIG[:significant_points_heatmap_grid], CONFIG[:size]).to_a
-
-      templates = select_templates strokes, datastore
-
-      # Use threads to accelerate the process
-      Parallel.map(templates, in_threads: @thread_count) do |candidate|
-        candidate_heatmap = candidate[:heatmap_significant_points].split(",").map(&:to_f)
-
-        score = Math.euclidean_distance(heatmap, candidate_heatmap)
-        [score.round(3), candidate]
-      end
+    #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
+      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
@@ -38,28 +20,18 @@ module KvgCharacterRecognition
     #+strokes+:: strokes are not preprocessed
     #+datastore+:: JSONDatastore or custom datastore type having method characters_in_stroke_range(min..max)
     def self.scores strokes, datastore
-      #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
+      character = Trainer::Character.new(strokes, nil)
+      templates = select_templates character, datastore
 
-      #dump half of the templates after coarse recognition
-      #collection is in the form [[score, c1], [score, c2] ...]
-      collection = coarse_recognize(strokes, datastore).sort{ |a, b| a[0] <=> b[0] }
+      scores = templates.map do |cand|
 
-      scores = Parallel.map(collection.take(collection.count / 2)) do |cand|
-        direction_score = (Math.euclidean_distance(directions[0], cand[1][:direction_e1].split(",").map(&:to_f)) +
-                           Math.euclidean_distance(directions[1], cand[1][:direction_e2].split(",").map(&:to_f)) +
-                           Math.euclidean_distance(directions[2], cand[1][:direction_e3].split(",").map(&:to_f)) +
-                           Math.euclidean_distance(directions[3], cand[1][:direction_e4].split(",").map(&:to_f)) ) / 4
+        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_score = Math.euclidean_distance(heatmap_smoothed, cand[1][:heatmap_smoothed].split(",").map(&:to_f))
 
-        mix = (direction_score / 100) + heatmap_score
-        [mix/2, cand[1]]
+        [[heatmap_bi_moment_score, heatmap_line_density_score, heatmap_bi_moment_slant_score, heatmap_line_density_slant_score].min, cand]
       end
 
       scores.sort{ |a, b| a[0] <=> b[0] }

data/lib/kvg_character_recognition/trainer.rb

@@ -1,5 +1,43 @@
 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
+    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
@@ -18,31 +56,8 @@ module KvgCharacterRecognition
         #--------------
         #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])
 
+        chr = Character.new strokes, value
 
         #Store to database
         #--------------
@@ -50,13 +65,11 @@ module KvgCharacterRecognition
           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(",")
+          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

data/lib/kvg_character_recognition/utils.rb

@@ -10,6 +10,14 @@ module Math
     end
     Math.sqrt( sum_of_squares )
   end
+
+  def self.manhattan_distance(p1, p2)
+    sum = 0
+    p1.each_with_index do |p1_coord,index|
+      sum += (p1_coord - p2[index]).abs
+    end
+    sum
+  end
 end
 
 module KvgCharacterRecognition

data/lib/kvg_character_recognition/version.rb

@@ -1,3 +1,3 @@
 module KvgCharacterRecognition
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: kvg_character_recognition
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Jiayi Zheng
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-17 00:00:00.000000000 Z
+date: 2016-01-31 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: parallel
-  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: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -118,7 +104,6 @@ files:
 - kvg_character_recognition.gemspec
 - lib/kvg_character_recognition.rb
 - lib/kvg_character_recognition/datastore.rb
-- lib/kvg_character_recognition/feature_extractor.rb
 - lib/kvg_character_recognition/preprocessor.rb
 - lib/kvg_character_recognition/recognizer.rb
 - lib/kvg_character_recognition/trainer.rb

data/lib/kvg_character_recognition/feature_extractor.rb

@@ -1,168 +0,0 @@
-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