nayutaya-googlemaps-polyline 0.0.1

data/README.md

@@ -0,0 +1,10 @@
+
+# googlemaps-polyline
+
+googlemaps-polylineは、Google Maps APIのエンコード化ポリラインを取り扱う
+ためのライブラリです。
+ポリラインのエンコード、デコードを行うことができます。
+
+## インストール
+
+  $ gem install nayutaya-googlemaps-polyline

data/Rakefile

@@ -0,0 +1,70 @@
+
+require "rake/testtask"
+require "lib/googlemaps_polyline/version"
+
+PACKAGE_NAME    = "nayutaya-googlemaps-polyline"
+PACKAGE_VERSION = GoogleMapsPolyline::VERSION
+
+task :default => :test
+
+Rake::TestTask.new do |test|
+  test.libs << "test"
+  test.test_files = Dir.glob("test/**/*_test.rb")
+  test.verbose    =  true
+end
+
+namespace :version do
+  desc "show current version"
+  task :show do
+    puts(PACKAGE_VERSION)
+  end
+
+  desc "bump version"
+  task :bump do
+    cur_version  = PACKAGE_VERSION
+    next_version = cur_version.succ
+    puts("#{cur_version} -> #{next_version}")
+
+    filename = File.join(File.dirname(__FILE__), "lib", "googlemaps_polyline", "version.rb")
+    File.open(filename, "wb") { |file|
+      file.puts(%|# coding: utf-8|)
+      file.puts(%||)
+      file.puts(%|module GoogleMapsPolyline|)
+      file.puts(%|  VERSION = "#{next_version}"|)
+      file.puts(%|end|)
+    }
+  end
+end
+
+namespace :gem do
+  desc "generate gemspec"
+  task :spec do
+    require "erb"
+
+    src = File.open("#{PACKAGE_NAME}.gemspec.erb", "rb") { |file| file.read }
+    erb = ERB.new(src, nil, "-")
+
+    files = Dir.glob("**/*").
+      select { |s| File.file?(s) }.
+      reject { |s| /\.gem\z/ =~ s }.
+      reject { |s| /\Anbproject\// =~ s }
+
+    test_files = Dir.glob("test/**").
+      select { |s| File.file?(s) }
+
+    File.open("#{PACKAGE_NAME}.gemspec", "wb") { |file|
+      file.write(erb.result(binding))
+    }
+  end
+
+  desc "build gem"
+  task :build do
+    sh "gem build #{PACKAGE_NAME}.gemspec"
+  end
+
+  desc "push gem"
+  task :push do
+    target = "#{PACKAGE_NAME}-#{PACKAGE_VERSION}.gem"
+    sh "gem push #{target}"
+  end
+end

data/lib/googlemaps_polyline.rb

@@ -0,0 +1,4 @@
+# coding: utf-8
+
+require "googlemaps_polyline/version"
+require "googlemaps_polyline/core"

data/lib/googlemaps_polyline/core.rb

@@ -0,0 +1,39 @@
+# coding: utf-8
+
+require "googlemaps_polyline/encoder"
+require "googlemaps_polyline/decoder"
+
+module GoogleMapsPolyline
+  def self.encode_points_and_levels(points, levels)
+    encoded_points = Encoder.new(StringIO.new).encode_points(points).string
+    encoded_levels = Encoder.new(StringIO.new).encode_levels(levels).string
+    return encoded_points, encoded_levels
+  end
+
+  def self.encode_polyline_1e5(records)
+    points = records.map { |record| record[0..1] }
+    levels = records.map { |record| record[2] }
+    return self.encode_points_and_levels(points, levels)
+  end
+
+  def self.encode_polyline(records)
+    records_1e5 = records.map { |lat, lng, level| [(lat * 1e5).to_i, (lng * 1e5).to_i, level] }
+    return self.encode_polyline_1e5(records_1e5)
+  end
+
+  def self.decode_points_and_levels(points, levels)
+    decoded_points = Decoder.new(StringIO.new(points)).decode_points
+    decoded_levels = Decoder.new(StringIO.new(levels)).decode_levels
+    return decoded_points, decoded_levels
+  end
+
+  def self.decode_polyline_1e5(points, levels)
+    decoded_points, decoded_levels = self.decode_points_and_levels(points, levels)
+    return decoded_points.zip(decoded_levels).map { |a| a.flatten }
+  end
+
+  def self.decode_polyline(points, levels)
+    records = self.decode_polyline_1e5(points, levels)
+    return records.map { |lat, lng, level| [lat.to_f / 1e5, lng.to_f / 1e5, level] }
+  end
+end

data/lib/googlemaps_polyline/decoder.rb

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+module GoogleMapsPolyline
+  class Decoder
+    def initialize(io)
+      @io = io
+    end
+
+    attr_reader :io
+
+    def decode_points
+      points = []
+
+      until @io.eof?
+        lat = read_point(@io)
+        lng = read_point(@io)
+
+        unless points.empty?
+          lat += points.last[0]
+          lng += points.last[1]
+        end
+
+        points << [lat, lng]
+      end
+
+      return points
+    end
+
+    def decode_levels
+      levels = []
+
+      until @io.eof?
+        levels << read_level(@io)
+      end
+
+      return levels
+    end
+
+    private
+
+    def read_point(io)
+      codes = []
+
+      while (char = io.read(1))
+        code = char.unpack("C")[0] - 63
+        codes << (code & ~0x20)
+        break if code & 0x20 == 0
+      end
+
+      raise(ArgumentError) unless (1..6).include?(codes.size)
+
+      bin = codes.map { |c| '%05b' % c }.reverse.join("")
+
+      negative = (bin.slice!(-1, 1) == "1")
+
+      num  = bin.to_i(2)
+      num *= -1 if negative
+      num += -1 if negative
+
+      return num
+    end
+
+    def read_level(io)
+      case io.read(1)
+      when "?" then return 0
+      when "@" then return 1
+      when "A" then return 2
+      when "B" then return 3
+      else raise(ArgumentError)
+      end
+    end
+  end
+end

data/lib/googlemaps_polyline/encoder.rb

@@ -0,0 +1,64 @@
+# coding: utf-8
+
+module GoogleMapsPolyline
+  class Encoder
+    def initialize(io)
+      @io = io
+    end
+
+    attr_reader :io
+
+    def encode_points(points)
+      plat, plng = 0, 0
+      points.each { |lat, lng|
+        @io.write(pack_point(lat - plat))
+        @io.write(pack_point(lng - plng))
+        plat, plng = lat, lng
+      }
+
+      return @io
+    end
+
+    def encode_levels(levels)
+      levels.each { |level|
+        @io.write(pack_level(level))
+      }
+
+      return @io
+    end
+
+    private
+
+    def pack_point(num)
+      negative = (num < 0)
+      if negative
+        num -= -1
+        num *= -1
+      end
+
+      num <<= 1
+      num  |= 1 if negative
+
+      codes = []
+
+      begin
+        code = (num & 0b11111) + 63
+        num >>= 5
+        code += 0x20 if num > 0
+        codes << code
+      end while num > 0
+
+      return codes.pack("C*")
+    end
+
+    def pack_level(level)
+      case level
+      when 0 then return "?"
+      when 1 then return "@"
+      when 2 then return "A"
+      when 3 then return "B"
+      else raise(ArgumentError)
+      end
+    end
+  end
+end

data/lib/googlemaps_polyline/version.rb

@@ -0,0 +1,5 @@
+# coding: utf-8
+
+module GoogleMapsPolyline
+  VERSION = "0.0.1"
+end

data/nayutaya-googlemaps-polyline.gemspec

@@ -0,0 +1,44 @@
+
+Gem::Specification.new do |s|
+  s.specification_version     = 2
+  s.required_rubygems_version = Gem::Requirement.new(">= 0")
+  s.required_ruby_version     = Gem::Requirement.new(">= 1.8.6")
+
+  s.name    = "nayutaya-googlemaps-polyline"
+  s.version = "0.0.1"
+  s.date    = "2010-03-23"
+
+  s.authors = ["Yuya Kato"]
+  s.email   = "yuyakato@gmail.com"
+
+  s.summary     = "Google Maps Polyline Utility"
+  s.description = "Polyline Encoder/Decoder for Google Maps API"
+  s.homepage    = "http://github.com/nayutaya/googlemaps-polyline/"
+
+  s.rubyforge_project = nil
+  s.has_rdoc          = false
+  s.require_paths     = ["lib"]
+
+  s.files = [
+    "lib/googlemaps_polyline/core.rb",
+    "lib/googlemaps_polyline/decoder.rb",
+    "lib/googlemaps_polyline/encoder.rb",
+    "lib/googlemaps_polyline/version.rb",
+    "lib/googlemaps_polyline.rb",
+    "nayutaya-googlemaps-polyline.gemspec",
+    "nayutaya-googlemaps-polyline.gemspec.erb",
+    "Rakefile",
+    "README.md",
+    "test/core_test.rb",
+    "test/decoder_test.rb",
+    "test/encoder_test.rb",
+    "test/test_helper.rb",
+  ]
+  s.test_files = [
+    "test/core_test.rb",
+    "test/decoder_test.rb",
+    "test/encoder_test.rb",
+    "test/test_helper.rb",
+  ]
+  s.extra_rdoc_files = []
+end

data/nayutaya-googlemaps-polyline.gemspec.erb

@@ -0,0 +1,33 @@
+
+Gem::Specification.new do |s|
+  s.specification_version     = 2
+  s.required_rubygems_version = Gem::Requirement.new(">= 0")
+  s.required_ruby_version     = Gem::Requirement.new(">= 1.8.6")
+
+  s.name    = <%= PACKAGE_NAME.dump %>
+  s.version = <%= PACKAGE_VERSION.dump %>
+  s.date    = <%= Time.now.strftime("%Y-%m-%d").dump %>
+
+  s.authors = ["Yuya Kato"]
+  s.email   = "yuyakato@gmail.com"
+
+  s.summary     = "Google Maps Polyline Utility"
+  s.description = "Polyline Encoder/Decoder for Google Maps API"
+  s.homepage    = "http://github.com/nayutaya/googlemaps-polyline/"
+
+  s.rubyforge_project = nil
+  s.has_rdoc          = false
+  s.require_paths     = ["lib"]
+
+  s.files = [
+<%- files.each { |path| -%>
+    <%= path.dump %>,
+<%- } -%>
+  ]
+  s.test_files = [
+<%- test_files.each { |path| -%>
+    <%= path.dump %>,
+<%- } -%>
+  ]
+  s.extra_rdoc_files = []
+end

data/test/core_test.rb

@@ -0,0 +1,76 @@
+# coding: utf-8
+
+require "test_helper"
+require "googlemaps_polyline/core"
+
+class CoreTest < Test::Unit::TestCase
+  def setup
+    @mod = GoogleMapsPolyline
+  end
+
+  def test_encode_points_and_levels
+    points, levels = @mod.encode_points_and_levels([[0, 0]], [3])
+    assert_equal("??", points)
+    assert_equal("B",  levels)
+  end
+
+  def test_encode_polyline_1e5__1
+    points, levels = @mod.encode_polyline_1e5([[0, 0, 3]])
+    assert_equal("??", points)
+    assert_equal("B",  levels)
+  end
+
+  def test_encode_polyline_1e5__1
+    points, levels = @mod.encode_polyline_1e5(
+      [[1, 2, 3], [2, 4, 2], [3, 8, 1], [4, 16, 0], [5, 32, 3]])
+    assert_equal("ACACAGAOA_@", points)
+    assert_equal("BA@?B",       levels)
+  end
+
+  def test_encode_polyline
+    points, levels = @mod.encode_polyline(
+      [[34.69025, 135.19501, 3], [34.69363, 135.50192, 3]])
+    assert_equal("amvrEygdxXcTe}z@", points)
+    assert_equal("BB",               levels)
+  end
+
+  def test_decode_points_and_levels
+    expected = [[[0, 0]], [3]]
+    assert_equal(
+      expected,
+      @mod.decode_points_and_levels("??", "B"))
+  end
+
+  def test_decode_polyline_1e5__1
+    expected = [[0, 0, 3]]
+    assert_equal(
+      expected,
+      @mod.decode_polyline_1e5("??", "B"))
+  end
+
+  def test_decode_polyline_1e5__2
+    expected = [[1, 2, 3], [2, 4, 2], [3, 8, 1], [4, 16, 0], [5, 32, 3]]
+    assert_equal(
+      expected,
+      @mod.decode_polyline_1e5("ACACAGAOA_@", "BA@?B"))
+  end
+
+  def test_decode_polyline
+    expected = [[34.69025, 135.19501, 3], [34.69363, 135.50192, 3]]
+    assert_equal(
+      expected,
+      @mod.decode_polyline("amvrEygdxXcTe}z@", "BB"))
+  end
+
+  def test_encode_and_decode
+    srand(0)
+    points1 = 20.times.map { [rand(180 * 1e5) - 90 * 1e5, rand(360 * 1e5) - 180 * 1e5] }.map { |lat, lng| [lat.to_i, lng.to_i] }
+    levels1 = [3] + 18.times.map { rand(4) } + [3]
+
+    points2, levels2 = @mod.encode_points_and_levels(points1, levels1)
+    points3, levels3 = @mod.decode_points_and_levels(points2, levels2)
+
+    assert_equal(points1, points3)
+    assert_equal(levels1, levels3)
+  end
+end

data/test/decoder_test.rb

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+require "test_helper"
+require "googlemaps_polyline/decoder"
+require "stringio"
+
+class DecoderTest < Test::Unit::TestCase
+  def setup
+    @klass = GoogleMapsPolyline::Decoder
+  end
+
+  def test_initialize
+    io = sio
+    encoder = @klass.new(io)
+    assert_same(io, encoder.io)
+  end
+
+  def test_decode_points__1
+    assert_equal(
+      [[0, 0]],
+      @klass.new(sio("??")).decode_points)
+  end
+
+  def test_decode_points__2
+    assert_equal(
+      [[0, 0], [0, 0]],
+      @klass.new(sio("????")).decode_points)
+  end
+
+  def test_decode_points__3
+    assert_equal(
+      [[1, 0]],
+      @klass.new(sio("A?")).decode_points)
+  end
+
+  def test_decode_points__4
+    assert_equal(
+      [[0, 1]],
+      @klass.new(sio("?A")).decode_points)
+  end
+
+  def test_decode_points__5
+    assert_equal(
+      [[1, 1], [1, 1]],
+      @klass.new(sio("AA??")).decode_points)
+  end
+
+  def test_decode_points__6
+    assert_equal(
+      [[1, 2], [2, 4], [3, 8], [4, 16], [5, 32]],
+      @klass.new(sio("ACACAGAOA_@")).decode_points)
+  end
+
+  def test_decode_levels
+    assert_equal(
+      [0, 1, 2, 3],
+      @klass.new(sio("?@AB")).decode_levels)
+  end
+
+  def test_read_point
+    decoder = @klass.new(sio)
+    read_point = proc { |io| decoder.instance_eval { read_point(io) } }
+    assert_equal(        0, read_point[sio("?")])
+    assert_equal(        1, read_point[sio("A")])
+    assert_equal(       -1, read_point[sio("@")])
+    assert_equal( 12345678, read_point[sio("{sopV")])
+    assert_equal(-12345678, read_point[sio("zsopV")])
+    assert_equal( 18000000, read_point[sio("_gsia@")])
+    assert_equal(-18000000, read_point[sio("~fsia@")])
+    assert_raise(ArgumentError) { read_point[sio("")] }
+  end
+
+  def test_read_level
+    decoder = @klass.new(sio)
+    read_level = proc { |io| decoder.instance_eval { read_level(io) } }
+    assert_equal(0, read_level[sio("?")])
+    assert_equal(1, read_level[sio("@")])
+    assert_equal(2, read_level[sio("A")])
+    assert_equal(3, read_level[sio("B")])
+    assert_raise(ArgumentError) { read_level[sio("")] }
+  end
+
+  private
+
+  def sio(string = nil)
+    return StringIO.new(string || "")
+  end
+end

data/test/encoder_test.rb

@@ -0,0 +1,97 @@
+# coding: utf-8
+
+require "test_helper"
+require "googlemaps_polyline/encoder"
+require "stringio"
+
+class EncoderTest < Test::Unit::TestCase
+  def setup
+    @klass   = GoogleMapsPolyline::Encoder
+    @encoder = @klass.new(sio)
+  end
+
+  def test_initialize
+    io = sio
+    encoder = @klass.new(io)
+    assert_same(io, encoder.io)
+  end
+
+  def test_encode_points__1
+    assert_equal(
+      "",
+      @encoder.encode_points([]).string)
+  end
+
+  def test_encode_points__2
+    assert_equal(
+      "??",
+      @encoder.encode_points([[0, 0]]).string)
+  end
+
+  def test_encode_points__3
+    assert_equal(
+      "????",
+      @encoder.encode_points([[0, 0], [0, 0]]).string)
+  end
+
+  def test_encode_points__4
+    assert_equal(
+      "A?",
+      @encoder.encode_points([[1, 0]]).string)
+  end
+
+  def test_encode_points__5
+    assert_equal(
+      "?A",
+      @encoder.encode_points([[0, 1]]).string)
+  end
+
+  def test_encode_points__6
+    assert_equal(
+      "AA??",
+      @encoder.encode_points([[1, 1], [1, 1]]).string)
+  end
+
+  def test_encode_points__7
+    assert_equal(
+      "ACACAGAOA_@",
+      @encoder.encode_points([[1, 2], [2, 4], [3, 8], [4, 16], [5, 32]]).string)
+  end
+
+  def test_encode_levels
+    assert_equal(
+      "?@AB",
+      @encoder.encode_levels([0, 1, 2, 3]).string)
+  end
+
+  def test_pack_point
+    pack_point = proc { |num| @encoder.instance_eval { pack_point(num) } }
+    assert_equal("?"     , pack_point[        0])
+    assert_equal("A"     , pack_point[        1])
+    assert_equal("@"     , pack_point[       -1])
+    assert_equal("{sopV" , pack_point[ 12345678])
+    assert_equal("zsopV" , pack_point[-12345678])
+    assert_equal("_gsia@", pack_point[ 18000000])
+    assert_equal("~fsia@", pack_point[-18000000])
+  end
+
+  def test_pack_level
+    pack_level = proc { |level| @encoder.instance_eval { pack_level(level) } }
+    assert_equal("?", pack_level[0])
+    assert_equal("@", pack_level[1])
+    assert_equal("A", pack_level[2])
+    assert_equal("B", pack_level[3])
+  end
+
+  def test_pack_level__invalid
+    assert_raise(ArgumentError) {
+      @encoder.instance_eval { pack_level(-1) }
+    }
+  end
+
+  private
+
+  def sio(string = nil)
+    return StringIO.new(string || "")
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "test/unit"
+
+begin
+  require "rubygems"
+  require "redgreen"
+  require "win32console" if /win32/ =~ RUBY_PLATFORM
+rescue LoadError
+  # nop
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: nayutaya-googlemaps-polyline
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Yuya Kato
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-23 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: Polyline Encoder/Decoder for Google Maps API
+email: yuyakato@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/googlemaps_polyline/core.rb
+- lib/googlemaps_polyline/decoder.rb
+- lib/googlemaps_polyline/encoder.rb
+- lib/googlemaps_polyline/version.rb
+- lib/googlemaps_polyline.rb
+- nayutaya-googlemaps-polyline.gemspec
+- nayutaya-googlemaps-polyline.gemspec.erb
+- Rakefile
+- README.md
+- test/core_test.rb
+- test/decoder_test.rb
+- test/encoder_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/nayutaya/googlemaps-polyline/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: Google Maps Polyline Utility
+test_files: 
+- test/core_test.rb
+- test/decoder_test.rb
+- test/encoder_test.rb
+- test/test_helper.rb