fast-polylines 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cf28bc2bb47a05f419d1366ecb38d2b33e22af0e
+  data.tar.gz: b0fb22fcb016fd2397a4dcc4b7346772a8dcabae
+SHA512:
+  metadata.gz: e74e05e39f67996941bf7409d8e7daa526d1578be1e2e3f1f3bbe7dcb564bd22908fd3eaeeb6f17ac3f47e017b7ff54e0554fd3b5a1c91f0a981f08b42c678fe
+  data.tar.gz: 5041a5e03079af6a48f50c8f0796382deed04e422cc1721c12edfabcdb19b9bcc5c2ca6bd2505716fffe9dc4d7f43ae61d3a262c5055a888bc0f121e668730ed

data/README.md

@@ -0,0 +1,47 @@
+# Fast Polylines
+
+Implementation of the Google polyline algorithm :
+http://code.google.com/apis/maps/documentation/utilities/polylinealgorithm.html
+
+Inspired by Joshua Clayton gem : https://github.com/joshuaclayton/polylines
+
+But **at least a 5x faster implementation**.
+
+## Install
+
+```
+gem install fast-polylines
+```
+
+or in Bundler:
+```
+gem "fast-polylines"
+```
+
+## Usage
+
+```
+require 'fast-polylines'
+
+FastPolylines::Encoder.encode([[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]])
+# "_p~iF~ps|U_ulLnnqC_mqNvxq`@"
+
+FastPolylines::Decoder.decode("_p~iF~ps|U_ulLnnqC_mqNvxq`@")
+# [[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]]
+```
+
+## Advanced usage
+
+*  With a different precision (default precision of `1e5`) :
+
+```
+FastPolylines::Encoder.encode([[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]], 1e6)
+# "_izlhA~rlgdF_{geC~ywl@_kwzCn`{nI"
+
+FastPolylines::Decoder.decode("_izlhA~rlgdF_{geC~ywl@_kwzCn`{nI", 1e6)
+# [[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]]
+```
+
+## License
+
+Please see LICENSE

data/lib/fast-polylines/decoder.rb

@@ -0,0 +1,42 @@
+module FastPolylines
+  ##
+  # Provide an interface to decode a Google polyline
+  # to an array of lat / lng points
+  class Decoder
+    ##
+    # Decode a polyline to a list of points
+    #
+    # @param [String] polyline to be decoded
+    # @param [Float] precision of the polyline (default 1e5)
+    # @return [Array<Array>] A list of lat / lng pairs
+    def self.decode(polyline, precision = 1e5)
+      coords = []
+      acc = ""
+      polyline.each_byte do |b|
+        acc << b
+        next unless b < 0x5f
+        coords << acc
+        acc = ""
+      end
+      lat = lng = 0
+      coords.each_slice(2).map do |coords_pair|
+        lat += decode_number(coords_pair[0], precision)
+        lng += decode_number(coords_pair[1], precision)
+        [lat, lng]
+      end
+    end
+
+    def self.decode_number(string, precision = 1e5)
+      result = 1
+      shift = 0
+      string.each_byte do |b|
+        b = b - 63 - 1
+        result += b << shift
+        shift += 5
+      end
+      result = (result & 1).nonzero? ? (~result >> 1) : (result >> 1)
+      result / precision
+    end
+    private_class_method :decode_number
+  end
+end

data/lib/fast-polylines/encoder.rb

@@ -0,0 +1,47 @@
+module FastPolylines
+  ##
+  # Provides an interface to encode an array of lat / lng points
+  # to a Google polyline
+  #
+  class Encoder
+    ##
+    # Encode a list of points into a polyline string
+    #
+    # @param [Array<Array>] points as lat/lng pairs
+    # @param [Float] precision of the encoding (default 1e5)
+    # @return [String] the encoded polyline
+    def self.encode(points, precision = 1e5)
+      result = ""
+      last_lat = last_lng = 0
+      points.each do |point|
+        lat = (point[0] * precision).round
+        lng = (point[1] * precision).round
+        d_lat = lat - last_lat
+        d_lng = lng - last_lng
+        chunks_lat = encode_number(d_lat)
+        chunks_lng = encode_number(d_lng)
+        result << chunks_lat << chunks_lng
+        last_lat = lat
+        last_lng = lng
+      end
+      result
+    end
+
+    def self.encode_number(num)
+      sgn_num = num << 1
+      sgn_num = ~sgn_num if num < 0
+      encode_unsigned_number(sgn_num)
+    end
+
+    def self.encode_unsigned_number(num)
+      encoded = ""
+      while num >= 0x20
+        encoded << (0x20 | (num & 0x1f)) + 63
+        num = num >> 5
+      end
+      encoded << num + 63
+    end
+    private_class_method :encode_number
+    private_class_method :encode_unsigned_number
+  end
+end

data/lib/fast-polylines/version.rb

@@ -0,0 +1,3 @@
+module FastPolylines
+  VERSION = "0.1.0".freeze
+end

data/lib/fast-polylines.rb

@@ -0,0 +1,5 @@
+require "fast-polylines/encoder"
+require "fast-polylines/decoder"
+
+module FastPolylines
+end

data/spec/fast-polylines/decoder_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe FastPolylines::Decoder do
+  describe ".decode" do
+    let(:points) { [[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]] }
+    context "with default precision" do
+      let(:polyline) { "_p~iF~ps|U_ulLnnqC_mqNvxq`@" }
+      it "should decode a polyline correctly" do
+        expect(described_class.decode(polyline)).to eq points
+      end
+      it "should perform at least 5x faster than the Polylines gem" do
+        expect {
+          described_class.decode(polyline)
+        }.to perform_faster_than {
+          Polylines::Decoder.decode_polyline(polyline)
+        }.at_least(5).times
+      end
+    end
+    context "with 1e6 precision" do
+      let(:polyline) { "_izlhA~rlgdF_{geC~ywl@_kwzCn`{nI" }
+      it "should decode a polyline correctly" do
+        expect(described_class.decode(polyline, 1e6)).to eq points
+      end
+    end
+    context "with points that were close together" do
+      let(:points) { [[41.35222, -86.04563], [41.35222, -86.04544]] }
+      it "should decode a polyline correctly" do
+        expect(described_class.decode("krk{FdxdlO?e@")).to eq points
+      end
+    end
+  end
+end

data/spec/fast-polylines/encoder_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe FastPolylines::Encoder do
+  describe ".encode" do
+    let(:points)   { [[38.5, -120.2], [40.7, -120.95], [43.252, -126.453]] }
+    context "with default precision" do
+      let(:polyline) { "_p~iF~ps|U_ulLnnqC_mqNvxq`@" }
+      it "should encode points correctly" do
+        expect(described_class.encode(points)).to eq polyline
+      end
+      it "should perform at least 5x faster than the Polylines gem" do
+        expect {
+          described_class.encode(points)
+        }.to perform_faster_than {
+          Polylines::Encoder.encode_points(points)
+        }.at_least(5).times
+      end
+    end
+    context "with 1e6 precision" do
+      let(:polyline) { "_izlhA~rlgdF_{geC~ywl@_kwzCn`{nI" }
+      it "should encode points correctly" do
+        expect(described_class.encode(points, 1e6)).to eq polyline
+      end
+    end
+    context "with points that were close together" do
+      let(:points) { [[41.35222, -86.04563], [41.35222, -86.04544]] }
+      it "should encode points correctly" do
+        expect(described_class.encode(points)).to eq "krk{FdxdlO?e@"
+      end
+    end
+    context "with possible rounding ambiguity" do
+      let(:points) { [[39.13594499,-94.4243478], [39.13558757,-94.4243471]] }
+      it "should encode points as Google API do" do
+        expect(described_class.encode(points)).to eq "svzmFdgi_QdA?"
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require "rubygems"
+require "bundler/setup"
+
+require "fast-polylines"
+
+require "rspec-benchmark"
+require "polylines"
+
+RSpec.configure do |config|
+  include RSpec::Benchmark::Matchers
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: fast-polylines
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Cyrille Courtière
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: polylines
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: rspec-benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: 
+email:
+- cyrille@wayzup.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/fast-polylines.rb
+- lib/fast-polylines/decoder.rb
+- lib/fast-polylines/encoder.rb
+- lib/fast-polylines/version.rb
+- spec/fast-polylines/decoder_spec.rb
+- spec/fast-polylines/encoder_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/wayzup/fast-polylines
+licenses:
+- MIT
+metadata: {}
+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.6.8
+signing_key: 
+specification_version: 4
+summary: Fast & easy Google polylines
+test_files:
+- spec/fast-polylines/decoder_spec.rb
+- spec/fast-polylines/encoder_spec.rb
+- spec/spec_helper.rb