simplify_rb 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 25ddf7e1fd393b6bcfe5c5f13a07fe3d01de5077
-  data.tar.gz: 2f46c665b134257da7bb0f0a205386d7e7c72a57
+  metadata.gz: 33cd91e84b17826cf512f3b17083e297b65c3268
+  data.tar.gz: 48d4337b44170364e78f3e206e5b19a90a84d567
 SHA512:
-  metadata.gz: 87e8a58fa61d2afcc0d3b769e9f2713639b980a180efc7382430dbf38521a6edc09e2442751c5d6b11fc8dd38a867b49ca3c073db1915b8c697a87add825571f
-  data.tar.gz: be9911eedb076f6fc15b4e6ff03587c785b654e6a51e668f2f8785bfa77a3612b1ae807039d2c0b19f0782f1223f0cba33ee763232d54f1580b2ae2d8d042f3f
+  metadata.gz: fd402062db3e2892fd4a1ce5aa8223b47f03daf465be61d397b874c19630aaa7085269ade4ed93c1be6cb45f61d1e092075e962587c3f174383cfd27aaa12468
+  data.tar.gz: 9a4baf26c41e5d912767840a811847d1bd65b3ccac19e16b9b743a2a7ef5ac21d515f944c92631e8fbe55aa280b47c6029aec77d7c50a5f86234f46cc86be72a

data/README.md

@@ -6,20 +6,6 @@ SimplifyRb is a Ruby port of [simplify.js](https://github.com/mourner/simplify-j
 
 You can use this gem to reduce the number of points in a complex polyline / polygon, making use of an optimized Douglas-Peucker algorithm.
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'simplify_rb'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install simplify_rb
-
 ## Usage
 
 ```ruby
@@ -40,3 +26,35 @@ SimplifyRb::Simplifier.new.process(points, tolerance, high_quality)
 ```tolerance```: (optional, 1 by default): Affects the amount of simplification that occurs (the smaller, the less simplification).
 
 ```high_quality```: (optional, False by default): Flag to exclude the distance pre-processing. Produces higher quality results when true is passed, but runs slower.
+
+### Custom points
+
+You can also use custom points, such as a struct or object which responds to `:x` and `:y`, rather than hashes:
+
+```ruby
+CustomPointStruct = Struct.new(:x, :y)
+
+custom_points = [
+  CustomPointStruct.new(51.5256, -0.0875),
+  CustomPointStruct.new(51.7823, -0.0912)
+]
+
+tolerance = 1
+high_quality = true
+
+SimplifyRb::Simplifier.new.process(custom_points, tolerance, high_quality)
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'simplify_rb'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install simplify_rb

data/Rakefile

@@ -1,5 +1,5 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 task default: [:spec]

data/lib/simplify_rb/douglas_peucker_simplifier.rb

@@ -0,0 +1,82 @@
+# Optimized Douglas-Peucker algorithm
+
+module SimplifyRb
+  class DouglasPeuckerSimplifier
+    def process(points, sq_tolerance)
+      points.first.keep = true
+      points.last.keep  = true
+
+      simplify_douglas_peucker(points, sq_tolerance)
+        .select(&:keep)
+    end
+
+    private
+
+    MaxSqDist = Struct.new(:max_sq_dist, :index)
+
+    def simplify_douglas_peucker(points, sq_tolerance)
+      first_i = 0
+      last_i  = points.length - 1
+      index = nil
+      stack = []
+
+      while last_i
+        result = calc_max_sq_dist(first_i, last_i, points)
+        index = result.index
+
+        if result.max_sq_dist > sq_tolerance
+          points[index].keep = true
+
+          stack.push(first_i, index, index, last_i)
+        end
+
+        first_i, last_i = stack.pop(2)
+      end
+
+      points
+    end
+
+    def calc_max_sq_dist(first_i, last_i, points)
+      index = nil
+      max_sq_dist = 0
+      range = (first_i + 1)...last_i
+
+      range.each do |i|
+        sq_dist = get_sq_seg_dist(points[i], points[first_i], points[last_i])
+
+        if sq_dist > max_sq_dist
+          index = i
+          max_sq_dist = sq_dist
+        end
+      end
+
+      MaxSqDist.new(max_sq_dist, index)
+    end
+
+    # Square distance from a point to a segment
+    def get_sq_seg_dist(point, point_1, point_2)
+      x  = point_1.x
+      y  = point_1.y
+      dx = point_2.x - x
+      dy = point_2.y - y
+
+      if dx != 0 || dy != 0
+        t = ((point.x - x) * dx + (point.y - y) * dy) / (dx * dx + dy * dy)
+
+        if t > 1
+          x = point_2.x
+          y = point_2.y
+
+        elsif t > 0
+          x += dx * t
+          y += dy * t
+        end
+      end
+
+      dx = point.x - x
+      dy = point.y - y
+
+      dx * dx + dy * dy
+    end
+  end
+end

data/lib/simplify_rb/point.rb

@@ -0,0 +1,39 @@
+module SimplifyRb
+  class Point
+    attr_reader :x, :y, :original_entity
+    attr_accessor :keep
+
+    def initialize(raw_point)
+      @original_entity = raw_point
+      @x, @y = parse_x_y(raw_point)
+    end
+
+    def get_sq_dist_to(other_point)
+      dx = x - other_point.x
+      dy = y - other_point.y
+
+      dx * dx + dy * dy
+    end
+
+    private
+
+    def parse_x_y(raw_point)
+      x = nil
+      y = nil
+
+      if raw_point.kind_of? Hash
+        x = raw_point[:x] || raw_point['x']
+        y = raw_point[:y] || raw_point['y']
+      elsif raw_point.respond_to?(:x) && raw_point.respond_to?(:y)
+        x = raw_point.x
+        y = raw_point.y
+      end
+
+      if x.nil? || y.nil?
+        raise ArgumentError.new('Points must have :x and :y values')
+      end
+
+      [x, y]
+    end
+  end
+end

data/lib/simplify_rb/radial_distance_simplifier.rb

@@ -0,0 +1,18 @@
+# Basic distance-based simplification
+
+module SimplifyRb
+  class RadialDistanceSimplifier
+    def process(points, sq_tolerance)
+      new_points = [points.first]
+
+      points.each do |point|
+        sq_dist = point.get_sq_dist_to(new_points.last)
+        new_points << point if sq_dist > sq_tolerance
+      end
+
+      new_points << points.last unless new_points.last == points.last
+
+      new_points
+    end
+  end
+end

data/lib/simplify_rb/version.rb

@@ -1,3 +1,3 @@
 module SimplifyRb
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/simplify_rb.rb

@@ -1,107 +1,26 @@
 require 'simplify_rb/version'
-require 'simplify_rb/symbolizer'
+require 'simplify_rb/point'
+require 'simplify_rb/radial_distance_simplifier'
+require 'simplify_rb/douglas_peucker_simplifier'
 
 module SimplifyRb
   class Simplifier
-    def process(points, tolerance = 1, highest_quality = false)
-      raise ArgumentError.new('Points must be an array') unless points.is_a? Array
+    def process(raw_points, tolerance = 1, highest_quality = false)
+      raise ArgumentError.new('Points must be an array') unless raw_points.is_a? Array
 
-      return points if points.length <= 1
-
-      symbolizer = Symbolizer.new
-
-      points = symbolizer.symbolize_keys(points) unless points.all? { |p| symbolizer.keys_are_symbols?(p.keys) }
+      return raw_points if raw_points.length <= 1
 
       sq_tolerance = tolerance * tolerance
 
-      # Optimisation step 1
-      points = simplify_radial_dist(points, sq_tolerance) unless highest_quality
-
-      # Optimisation step 2
-      simplify_douglas_peucker(points, sq_tolerance)
-    end
-
-    private
-
-    # Basic distance-based simplification
-    def simplify_radial_dist(points, sq_tolerance)
-      new_points = [points.first]
-
-      points.each do |point|
-        new_points << point if (get_sq_dist(point, new_points.last) > sq_tolerance)
-      end
-
-      new_points << points.last unless new_points.last == points.last
-
-      new_points
-    end
-
-    # Simplification using optimized Douglas-Peucker algorithm with recursion elimination
-    def simplify_douglas_peucker(points, sq_tolerance)
-      first = 0
-      last  = points.length - 1
-      index = nil
-      stack = []
-
-      points.first[:keep] = true
-      points.last[:keep]  = true
-
-      while last
-        max_sq_dist = 0
+      points = raw_points.map { |p| Point.new(p) }
 
-        ((first + 1)...last).each do |i|
-          sq_dist = get_sq_seg_dist(points[i], points[first], points[last])
-
-          if sq_dist > max_sq_dist
-            index = i
-            max_sq_dist = sq_dist
-          end
-        end
-
-        if max_sq_dist > sq_tolerance
-          points[index][:keep] = true
-
-          stack.push(first, index, index, last)
-        end
-
-        first, last = stack.pop(2)
-      end # end while
-
-      points.select { |p| p[:keep] && p.delete(:keep) }
-    end
-
-    # Square distance between two points
-    def get_sq_dist(point_1, point_2)
-      dx = point_1[:x] - point_2[:x]
-      dy = point_1[:y] - point_2[:y]
-
-      dx * dx + dy * dy
-    end
-
-    # Square distance from a point to a segment
-    def get_sq_seg_dist(point, point_1, point_2)
-      x  = point_1[:x]
-      y  = point_1[:y]
-      dx = point_2[:x] - x
-      dy = point_2[:y] - y
-
-      if dx != 0 || dy != 0
-        t = ((point[:x] - x) * dx + (point[:y] - y) * dy) / (dx * dx + dy * dy)
-
-        if t > 1
-          x = point_2[:x]
-          y = point_2[:y]
-
-        elsif t > 0
-          x += dx * t
-          y += dy * t
-        end
+      unless highest_quality
+        points = RadialDistanceSimplifier.new.process(points, sq_tolerance)
       end
 
-      dx = point[:x] - x
-      dy = point[:y] - y
-
-      dx * dx + dy * dy
+      DouglasPeuckerSimplifier.new
+        .process(points, sq_tolerance)
+        .map(&:original_entity)
     end
   end
 end

data/spec/simplify_rb/point_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'simplify_rb/point'
+
+describe SimplifyRb::Point do
+  describe 'parsing hashes with string keys' do
+    it 'determines the :x, :y value' do
+      raw_point = { "x" => 51.5256, "y" => -0.0875 }
+      point = described_class.new(raw_point)
+
+      expect(point.x).to eq(51.5256)
+      expect(point.y).to eq(-0.0875)
+    end
+  end
+
+  describe 'parsing structs' do
+    it 'determines the :x, :y value' do
+      CustomPointStruct = Struct.new(:x, :y)
+      raw_point = CustomPointStruct.new(51.5256, -0.0875)
+
+      point = described_class.new(raw_point)
+
+      expect(point.x).to eq(51.5256)
+      expect(point.y).to eq(-0.0875)
+    end
+  end
+
+  describe 'handling raw points which are objects' do
+    it 'determines the :x, :y value' do
+      class MyCustomPoint
+        attr_reader :x, :y
+
+        def initialize(x, y)
+          @x = x
+          @y = y
+        end
+      end
+
+      raw_point = MyCustomPoint.new(51.5256, -0.0875)
+
+      point = described_class.new(raw_point)
+
+      expect(point.x).to eq(51.5256)
+      expect(point.y).to eq(-0.0875)
+    end
+  end
+
+  describe 'missing x/y values' do
+    it 'raises an error if the points are missing keys' do
+      invalid_point = { Z: 51.5256, y: -0.0875 }
+      expect { described_class.new(invalid_point) }.to raise_error(ArgumentError, 'Points must have :x and :y values')
+
+      invalid_point = { x: 51.5256, Z: -0.0875 }
+      expect { described_class.new(invalid_point) }.to raise_error(ArgumentError, 'Points must have :x and :y values')
+    end
+
+    it 'raises an error if points don\'t respond to x / y' do
+      class UnconventialPoint
+        attr_reader :a, :b
+
+        def initialize(a, b)
+          @a = a
+          @b = b
+        end
+      end
+
+      invalid_point = UnconventialPoint.new(51.5256, -0.0875)
+      expect { described_class.new(invalid_point) }.to raise_error(ArgumentError, 'Points must have :x and :y values')
+    end
+  end
+end

data/spec/simplify_rb_spec.rb

@@ -20,6 +20,22 @@ describe SimplifyRb::Simplifier do
       end
     end
 
+    describe 'extra properties on the data' do
+      it 'preserves the extra properties' do
+        richer_data = [
+          { x: 51.5256, y: -0.0875, note: 'Foo bar' },
+          { x: 51.7823, y: -0.0912, attr: 123 }
+        ]
+
+        result = subject.process(richer_data, 5, true)
+
+        expect(result.length).to eq 2
+
+        expect(result.first[:note]).to eq 'Foo bar'
+        expect(result.last[:attr]).to eq 123
+      end
+    end
+
     context 'only one point' do
       it 'returns a list with one point' do
         data = [{ x: 1, y: 2 }]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simplify_rb
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - odlp
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-29 00:00:00.000000000 Z
+date: 2016-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -69,15 +69,17 @@ files:
 - Rakefile
 - example/example.rb
 - lib/simplify_rb.rb
-- lib/simplify_rb/symbolizer.rb
+- lib/simplify_rb/douglas_peucker_simplifier.rb
+- lib/simplify_rb/point.rb
+- lib/simplify_rb/radial_distance_simplifier.rb
 - lib/simplify_rb/version.rb
 - simplify_rb.gemspec
 - spec/fixtures/all-points.yml
 - spec/fixtures/result-fast.yml
 - spec/fixtures/result-high-quality.yml
+- spec/simplify_rb/point_spec.rb
 - spec/simplify_rb_spec.rb
 - spec/spec_helper.rb
-- spec/symbolizer_spec.rb
 homepage: https://github.com/odlp/simplify_rb
 licenses:
 - MIT
@@ -106,6 +108,6 @@ test_files:
 - spec/fixtures/all-points.yml
 - spec/fixtures/result-fast.yml
 - spec/fixtures/result-high-quality.yml
+- spec/simplify_rb/point_spec.rb
 - spec/simplify_rb_spec.rb
 - spec/spec_helper.rb
-- spec/symbolizer_spec.rb

data/lib/simplify_rb/symbolizer.rb

@@ -1,13 +0,0 @@
-module SimplifyRb
-  class Symbolizer
-    def keys_are_symbols?(keys)
-      keys.all? { |k| k.is_a? Symbol }
-    end
-
-    def symbolize_keys(collection)
-      collection.map do |item|
-        item.each_with_object({}) { |(k,v), memo| memo[k.to_sym] = v }
-      end
-    end
-  end
-end

data/spec/symbolizer_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-require 'simplify_rb/symbolizer'
-
-describe SimplifyRb::Symbolizer do
-  describe '#keys_are_symbols?' do
-    it 'returns false if any key is not a Symbol' do
-      expect(subject.keys_are_symbols?([:a, 'b', :c])).to equal(false)
-    end
-
-    it 'returns return true if all the keys are Symbols' do
-      expect(subject.keys_are_symbols?([:a, :b, :c])).to equal(true)
-    end
-  end
-
-  describe '#symbolize_keys' do
-    it 'converts all of the collection\'s keys to symbols' do
-      collection = [{ 'a' => 1, 'b' => 2 }, { 'c' => 3 }]
-      symbolized_result = subject.symbolize_keys(collection)
-      expected_result = [{ a: 1, b: 2 }, { c: 3 }]
-
-      expect(symbolized_result).to eq(expected_result)
-    end
-  end
-end