geodelta 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 39c605312c9e7f3b221e430a07a1e464c4adc79f
+  data.tar.gz: 0134bef761ed3b2b298d28393ae7ea5ff51e551c
+SHA512:
+  metadata.gz: 236ca2f94b217453f6aa030a4d1756686ce3a1a71a41bd1aeaff6eabb4821d36e22bcfd9988e8a93b52caebefcc501059746da1df42d5f32dfb332189fee9d9e
+  data.tar.gz: c7ce33335afd0b74cdaa2a0819f2c6f8b879da52f94cd10649412ec55423a5e190758a6eb81aceb656a51ffa401cc844c0858370f8742726b91bae194e525052

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.ruby-version

data/Gemfile

@@ -0,0 +1,4 @@
+
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Yuya Kato (Nayutaya Inc.)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+# geodelta-ruby
+
+[![Code Climate](https://codeclimate.com/github/nayutaya/geodelta-ruby/badges/gpa.svg)](https://codeclimate.com/github/nayutaya/geodelta-ruby)
+[![Test Coverage](https://codeclimate.com/github/nayutaya/geodelta-ruby/badges/coverage.svg)](https://codeclimate.com/github/nayutaya/geodelta-ruby/coverage)
+[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/nayutaya/geodelta-ruby/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/nayutaya/geodelta-ruby/?branch=master)
+[![Circle CI](https://circleci.com/gh/nayutaya/geodelta-ruby.svg?style=shield)](https://circleci.com/gh/nayutaya/geodelta-ruby)
+[![Gem Version](https://badge.fury.io/rb/geodelta.svg)](http://badge.fury.io/rb/geodelta)
+
+An implementation of GeoDelta for Ruby.
+
+## Overview
+
+TODO
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "geodelta"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install geodelta
+
+## Usage
+
+TODO
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/nayutaya/geodelta-ruby/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## Author
+
+Yuya Kato (Nayutaya Inc.) <yuyakato@gmail.com>
+
+## License
+
+MIT License
+
+## Other languages
+
+* JavaScript: https://github.com/nayutaya/geodelta-js
+* Java: https://github.com/nayutaya/geodelta

data/Rakefile

@@ -0,0 +1,9 @@
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/*_test.rb"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "geodelta"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/circle.yml

@@ -0,0 +1,3 @@
+machine:
+  ruby:
+    version: 2.2.0

data/geodelta.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "geodelta/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "geodelta"
+  spec.version       = GeoDelta::VERSION
+  spec.authors       = ["Yuya Kato"]
+  spec.email         = ["yuyakato@gmail.com"]
+
+  spec.summary       = %q{An implementation of GeoDelta for Ruby.}
+  spec.description   = %q{An implementation of GeoDelta for Ruby.}
+  spec.homepage      = "https://github.com/nayutaya/geodelta-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| 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_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "codeclimate-test-reporter"
+end

data/lib/geodelta.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+
+require_relative "./geodelta/version"
+require_relative "./geodelta/core"

data/lib/geodelta/core.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require_relative "./projector"
+require_relative "./delta_geometry"
+require_relative "./encoder"
+
+module GeoDelta
+  def self.get_delta_ids(lat, lng, level)
+    nx, ny = GeoDelta::Projector.latlng_to_nxy(lat, lng)
+    return GeoDelta::DeltaGeometry.get_delta_ids(nx, ny, level)
+  end
+
+  def self.get_delta_code(lat, lng, level)
+    ids = self.get_delta_ids(lat, lng, level)
+    return GeoDelta::Encoder.encode(ids)
+  end
+
+  def self.get_center_from_delta_ids(ids)
+    nx, ny = GeoDelta::DeltaGeometry.get_center(ids)
+    return GeoDelta::Projector.nxy_to_latlng(nx, ny)
+  end
+
+  def self.get_center_from_delta_code(code)
+    ids = GeoDelta::Encoder.decode(code)
+    return self.get_center_from_delta_ids(ids)
+  end
+
+  def self.get_coordinates_from_ids(ids)
+    return GeoDelta::DeltaGeometry.get_coordinates(ids).
+      map { |nx, ny| GeoDelta::Projector.nxy_to_latlng(nx, ny) }
+  end
+
+  def self.get_coordinates_from_code(code)
+    ids = GeoDelta::Encoder.decode(code)
+    return self.get_coordinates_from_ids(ids)
+  end
+end

data/lib/geodelta/delta_geometry.rb

@@ -0,0 +1,180 @@
+# encoding: utf-8
+
+module GeoDelta
+  module DeltaGeometry
+    # 指定された座標(x,y)に該当するワールドデルタの番号を返す
+    # ただし、-12.0 <= x <= +12.0、-12.0 <= y <= +12.0
+    def self.get_world_delta_id(x, y)
+      xx = x % 24
+      yy = y.abs
+      return (y >= 0.0 ? 0 : 4) +
+        case
+        when yy >= +2.0 * (xx -  0.0) then 0
+        when yy <= -2.0 * (xx - 12.0) then 1
+        when yy >= +2.0 * (xx - 12.0) then 2
+        when yy <= -2.0 * (xx - 24.0) then 3
+        else                               0
+        end
+    end
+
+    # 指定された座標(x,y)に該当する上向きのサブデルタの番号を返す
+    # ただし、0.0 <= x <= +12.0、0.0 <= y <= +12.0
+    def self.get_upper_delta_id(x, y)
+      return 3 if y < -2.0 * (x - 6.0)
+      return 2 if y < +2.0 * (x - 6.0)
+      return 1 if y > 6.0
+      return 0
+    end
+
+    # 指定された座標(x,y)に該当する下向きのサブデルタの番号を返す
+    # ただし、0.0 <= x <= +12.0、0.0 <= y <= +12.0
+    def self.get_lower_delta_id(x, y)
+      return 3 if y > -2.0 * (x - 12.0)
+      return 2 if y > +2.0 * x
+      return 1 if y < 6.0
+      return 0
+    end
+
+    # 指定されたワールドデルタが上向きかどうかを返す
+    def self.upper_world_delta?(id)
+      return (id % 2 == (id < 4 ? 1 : 0))
+    end
+
+    # 指定されたサブデルタが上向きかどうか返す
+    def self.upper_sub_delta?(parent_is_upper, id)
+      return (parent_is_upper ? (id != 0) : (id == 0))
+    end
+
+    def self.upper_delta?(ids)
+      return ids.inject(nil) { |upper, id|
+        if upper.nil?
+          self.upper_world_delta?(id)
+        else
+          self.upper_sub_delta?(upper, id)
+        end
+      }
+    end
+
+    def self.transform_world_delta(id, x, y)
+      xx = (x + [+6.0, +0.0, -6.0, -12.0,  +6.0,  +0.0,  -6.0, -12.0][id]) % 12
+      yy = (y + [+0.0, +0.0, +0.0,  +0.0, +12.0, +12.0, +12.0, +12.0][id]) % 12
+      return [xx, yy]
+    end
+
+    def self.transform_upper_delta(id, x, y)
+      xx = (x + [-3.0, -3.0, -6.0, -0.0][id]) * 2
+      yy = (y + [-0.0, -6.0, -0.0, -0.0][id]) * 2
+      return [xx, yy]
+    end
+
+    def self.transform_lower_delta(id, x, y)
+      xx = (x + [-3.0, -3.0, -0.0, -6.0][id]) * 2
+      yy = (y + [-6.0, -0.0, -6.0, -6.0][id]) * 2
+      return [xx, yy]
+    end
+
+    def self.get_delta_ids(x, y, level)
+      ids    = [self.get_world_delta_id(x, y)]
+      xx, yy = self.transform_world_delta(ids.last, x, y)
+      upper  = self.upper_world_delta?(ids.last)
+
+      (level - 1).times {
+        if upper
+          ids   << self.get_upper_delta_id(xx, yy)
+          xx, yy = self.transform_upper_delta(ids.last, xx, yy)
+          upper  = self.upper_sub_delta?(upper, ids.last)
+        else
+          ids   << self.get_lower_delta_id(xx, yy)
+          xx, yy = self.transform_lower_delta(ids.last, xx, yy)
+          upper  = self.upper_sub_delta?(upper, ids.last)
+        end
+      }
+
+      return ids
+    end
+
+    def self.get_world_delta_center(id)
+      case id
+      when 0 then [ +0.0, +8.0]
+      when 1 then [ +6.0, +4.0]
+      when 2 then [+12.0, +8.0]
+      when 3 then [+18.0, +4.0]
+      when 4 then [ +0.0, -8.0]
+      when 5 then [ +6.0, -4.0]
+      when 6 then [+12.0, -8.0]
+      when 7 then [+18.0, -4.0]
+      end
+    end
+
+    def self.get_upper_sub_delta_distance(id)
+      case id
+      when 0 then [+0.0, +0.0]
+      when 1 then [+0.0, +4.0]
+      when 2 then [+3.0, -2.0]
+      when 3 then [-3.0, -2.0]
+      end
+    end
+
+    def self.get_lower_sub_delta_distance(id)
+      case id
+      when 0 then [+0.0, +0.0]
+      when 1 then [+0.0, -4.0]
+      when 2 then [-3.0, +2.0]
+      when 3 then [+3.0, +2.0]
+      end
+    end
+
+    def self.get_sub_delta_distance(parent_is_upper, id)
+      if parent_is_upper
+        return self.get_upper_sub_delta_distance(id)
+      else
+        return self.get_lower_sub_delta_distance(id)
+      end
+    end
+
+    def self.get_center(ids)
+      xs, ys = [], []
+      upper  = nil
+
+      ids.each_with_index { |id, index|
+        if index == 0
+          x, y  = self.get_world_delta_center(id)
+          upper = self.upper_world_delta?(id)
+          xs << x
+          ys << y
+        else
+          x, y  = self.get_sub_delta_distance(upper, id)
+          upper = self.upper_sub_delta?(upper, id)
+          xs << (x / (2 ** (index - 1)))
+          ys << (y / (2 ** (index - 1)))
+        end
+      }
+
+      x = xs.sort.inject(0.0, &:+)
+      y = ys.sort.inject(0.0, &:+)
+
+      x -= 24.0 if x > 12.0
+
+      return [x, y]
+    end
+
+    def self.get_coordinates(ids)
+      cx, cy = self.get_center(ids)
+      level  = ids.size
+      sign   = (self.upper_delta?(ids) ? +1 : -1)
+      scale  = 1.0 / (2 ** (level - 1)) * sign
+
+      dx1 = 0.0
+      dy1 = 8.0 * scale
+      dx2 = 6.0 * scale
+      dy2 = 4.0 * scale
+
+      return [
+        [cx,       cy      ],
+        [cx + dx1, cy + dy1],
+        [cx + dx2, cy - dy2],
+        [cx - dx2, cy - dy2],
+      ]
+    end
+  end
+end

data/lib/geodelta/encoder.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+module GeoDelta
+  module Encoder
+    WORLD_DELTA_TABLE = [
+      [0, "Z"],
+      [1, "Y"],
+      [2, "X"],
+      [3, "W"],
+      [4, "V"],
+      [5, "T"],
+      [6, "S"],
+      [7, "R"],
+    ].each(&:freeze).freeze
+    WORLD_ID_TO_CHAR = WORLD_DELTA_TABLE.inject({}) { |memo, (num, char)| memo[num] = char; memo }.freeze
+    WORLD_CHAR_TO_ID = WORLD_DELTA_TABLE.inject({}) { |memo, (num, char)| memo[char] = num; memo }.freeze
+
+    SUB_DELTA_TABLE = [
+      [[0, 0], "2"],
+      [[0, 1], "3"],
+      [[0, 2], "4"],
+      [[0, 3], "5"],
+      [[1, 0], "6"],
+      [[1, 1], "7"],
+      [[1, 2], "8"],
+      [[1, 3], "A"],
+      [[2, 0], "B"],
+      [[2, 1], "C"],
+      [[2, 2], "D"],
+      [[2, 3], "E"],
+      [[3, 0], "F"],
+      [[3, 1], "G"],
+      [[3, 2], "H"],
+      [[3, 3], "J"],
+      [[0]   , "K"],
+      [[1]   , "M"],
+      [[2]   , "N"],
+      [[3]   , "P"],
+    ].each(&:freeze).freeze
+    SUB_IDS_TO_CHAR = SUB_DELTA_TABLE.inject({}) { |memo, (nums, char)| memo[nums] = char; memo }.freeze
+    SUB_CHAR_TO_IDS = SUB_DELTA_TABLE.inject({}) { |memo, (nums, char)| memo[char] = nums; memo }.freeze
+
+    def self.encode_world_delta(id)
+      return WORLD_ID_TO_CHAR[id] || raise("invalid world delta id -- #{id}")
+    end
+
+    def self.decode_world_delta(code)
+      return WORLD_CHAR_TO_ID[code] || raise("invalid world delta code -- #{code}")
+    end
+
+    def self.encode_sub_delta(ids)
+      raise("sub delta ids is empty") if ids.empty?
+      return ids.each_slice(2).map { |part|
+        SUB_IDS_TO_CHAR[part] || raise("invalid sub delta ids -- #{part}")
+      }.join("")
+    end
+
+    def self.decode_sub_delta(codes)
+      raise("sub delta codes is empty") if codes.empty?
+      return codes.chars.inject([]) { |memo, char|
+        memo + (SUB_CHAR_TO_IDS[char] || raise("invalid sub delta code -- #{char}"))
+      }
+    end
+
+    def self.encode(ids)
+      raise("delta ids is empty") if ids.empty?
+      result  = self.encode_world_delta(ids[0])
+      result += self.encode_sub_delta(ids[1..-1]) if ids.size >= 2
+      return result
+    end
+
+    def self.decode(codes)
+      raise("delta codes is empty") if codes.empty?
+      result  = [self.decode_world_delta(codes[0])]
+      result += self.decode_sub_delta(codes[1..-1]) if codes.size >= 2
+      return result
+    end
+  end
+end

data/lib/geodelta/hex_geometry.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+require_relative "./delta_geometry"
+
+module GeoDelta
+  module HexGeometry
+    def self.get_hex_position(ids)
+      unit = get_unit(ids)
+      x, y = GeoDelta::DeltaGeometry.get_center(ids)
+      ix   = (x / unit * 2.0).floor % 6
+      iy   = (y / unit      ).floor % 2
+
+      case [ix, iy]
+      when [0, 0] then return 0
+      when [0, 1] then return 3
+      when [1, 0] then return 1
+      when [1, 1] then return 2
+      when [2, 0] then return 4
+      when [2, 1] then return 5
+      when [3, 0] then return 3
+      when [3, 1] then return 0
+      when [4, 0] then return 2
+      when [4, 1] then return 1
+      when [5, 0] then return 5
+      when [5, 1] then return 4
+      else raise "BUG [#{i}, #{j}]"
+      end
+    end
+
+    def self.get_base_delta_ids(ids)
+      unit = get_unit(ids)
+      ux   = unit / 2.0
+      uy   = unit / 3.0
+      pos  = self.get_hex_position(ids)
+      x, y = GeoDelta::DeltaGeometry.get_center(ids)
+
+      sx, sy =
+        case pos
+        when 0 then [0.0, 0.0    ]
+        when 1 then [-ux, +uy    ]
+        when 2 then [-ux, +uy * 3]
+        when 3 then [0.0, +uy * 4]
+        when 4 then [+ux, +uy * 3]
+        when 5 then [+ux, +uy    ]
+        else raise "BUG [#{pos}]"
+        end
+
+      return nil if x + sx > +12.0
+      return nil if x + sx < -12.0 + unit
+      return nil if y + sy > +12.0
+      return nil if y + sy < -12.0 + unit
+
+      return GeoDelta::DeltaGeometry.get_delta_ids(x + sx, y + sy, ids.size)
+    end
+
+    def self.get_part_delta_ids(base_ids)
+      level = base_ids.size
+      unit  = get_unit(base_ids)
+      x, y  = GeoDelta::DeltaGeometry.get_coordinates(base_ids)[1]
+
+      x1 = x - (unit / 2.0)
+      x2 = x
+      x3 = x + (unit / 2.0)
+
+      y1 = y + (unit * 2.0 / 3.0)
+      y2 = y + (unit / 3.0)
+      y3 = y - (unit / 3.0)
+      y4 = y - (unit * 2.0 / 3.0)
+
+      return [
+        [x2, y1],
+        [x3, y2],
+        [x3, y3],
+        [x2, y4],
+        [x1, y3],
+        [x1, y2],
+      ].map { |xx, yy|
+        GeoDelta::DeltaGeometry.get_delta_ids(xx, yy, level)
+      }
+    end
+
+    def self.get_coordinates(base_ids)
+      unit = get_unit(base_ids)
+      u1   = unit
+      u2   = unit / 2.0
+      x, y = GeoDelta::DeltaGeometry.get_coordinates(base_ids)[1]
+
+      return nil if y - u1 < -12.0
+
+      return [
+        [x     , y     ],
+        [x + u2, y + u1],
+        [x + u1, y     ],
+        [x + u2, y - u1],
+        [x - u2, y - u1],
+        [x - u1, y     ],
+        [x - u2, y + u1],
+      ]
+    end
+
+    def self.get_unit(ids)
+      level = ids.size
+      return 12.0 / (2 ** (level - 1))
+    end
+    private_class_method :get_unit
+  end
+end

data/lib/geodelta/hex_region.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require_relative "./region"
+require_relative "./hex_geometry"
+
+module GeoDelta
+  module HexRegion
+    def self.get_base_delta_ids_in_region(x1, y1, x2, y2, level)
+      deltas = GeoDelta::Region.get_delta_ids_in_region(x1, y1, x2, y2, level)
+      return deltas.map { |ids| GeoDelta::HexGeometry.get_base_delta_ids(ids) }.compact.sort.uniq
+    end
+  end
+end

data/lib/geodelta/id_util.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module GeoDelta
+  module IdUtil
+    def self.get_all_delta_ids(level)
+      return (0..7).map { |id| [id] } if level == 1
+      return (0..7).to_a.product(*([(0..3).to_a] * (level - 1)))
+    end
+  end
+end

data/lib/geodelta/packer32.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module GeoDelta
+  class Packer32
+    def pack_world_delta(id)
+      return id << 28
+    end
+
+    def unpack_world_delta(value)
+      return (value >> 28) & 0b111
+    end
+
+    def pack_sub_delta(level, id)
+      return id << (26 - ((level - 2) * 2))
+    end
+
+    def unpack_sub_delta(level, value)
+      return (value >> (26 - ((level - 2) * 2))) & 0b11
+    end
+
+    def pack_level(level)
+      return level
+    end
+
+    def unpack_level(value)
+      return value & 0b1111
+    end
+
+    def pack(ids)
+      wid   = self.pack_world_delta(ids[0])
+      sids  = ids[1..-1].each_with_index.map { |id, i| self.pack_sub_delta(i + 2, id) }.inject(0, &:+)
+      level = self.pack_level(ids.size)
+      return wid + sids + level
+    end
+
+    def unpack(value)
+      level = self.unpack_level(value)
+      wid   = self.unpack_world_delta(value)
+      sids  = (level - 1).times.map { |i| self.unpack_sub_delta(i + 2, value) }
+      return [wid] + sids
+    end
+  end
+end

data/lib/geodelta/packer64.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module GeoDelta
+  class Packer64
+    def pack_world_delta(id)
+      return id << 59
+    end
+
+    def unpack_world_delta(value)
+      return (value >> 59) & 0b111
+    end
+
+    def pack_sub_delta(level, id)
+      return id << (57 - ((level - 2) * 2))
+    end
+
+    def unpack_sub_delta(level, value)
+      return (value >> (57 - ((level - 2) * 2))) & 0b11
+    end
+
+    def pack_level(level)
+      return level
+    end
+
+    def unpack_level(level)
+      return level & 0b11111
+    end
+
+    def pack(ids)
+      wid   = self.pack_world_delta(ids[0])
+      sids  = ids[1..-1].each_with_index.map { |id, i| self.pack_sub_delta(i + 2, id) }.inject(0, &:+)
+      level = self.pack_level(ids.size)
+      return wid + sids + level
+    end
+
+    def unpack(value)
+      level = self.unpack_level(value)
+      wid   = self.unpack_world_delta(value)
+      sids  = (level - 1).times.map { |i| self.unpack_sub_delta(i + 2, value) }
+      return [wid] + sids
+    end
+  end
+end

data/lib/geodelta/projector.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+module GeoDelta
+  module Projector
+    DEG2RAD      = Math::PI / 180.0 # 度をラジアンに変換するための係数
+    RAD2DEG      = 180.0 / Math::PI # ラジアンを度に変換するための係数
+    DELTA_HEIGHT = Math.sqrt(0.75)  # 一辺を1.0とする正三角形の高さ
+
+    # 緯度をメルカトルY座標に変換する
+    #   -90.0 <= lat <= +90.0
+    #    -1.0 <= my  <=  +1.0
+    def self.lat_to_my(lat)
+      return Math.atanh(Math.sin(lat * DEG2RAD)) / Math::PI
+    end
+
+    # 経度をメルカトルX座標に変換する
+    #   -180.0 <= lng <= +180.0
+    #     -1.0 <= mx  <=   +1.0
+    def self.lng_to_mx(lng)
+      return lng / 180.0
+    end
+
+    # メルカトルY座標を緯度に変換する
+    #    -1.0 <= my  <=  +1.0
+    #   -90.0 <= lat <= +90.0
+    def self.my_to_lat(my)
+      return Math.asin(Math.tanh(my * Math::PI)) * RAD2DEG
+    end
+
+    # メルカトルX座標を経度に変換する
+    #     -1.0 <= mx  <=   +1.0
+    #   -180.0 <= lng <= +180.0
+    def self.mx_to_lng(mx)
+      mx  = (mx % 2.0) - 2.0
+      mx += 2.0 if mx < -1.0
+      return mx * 180.0
+    end
+
+    # メルカトルY座標から正規化Y座標に変換する
+    #    -1.0 <= my <=  +1.0
+    #   -12.0 <= ny <= +12.0
+    def self.my_to_ny(my)
+      return my / DELTA_HEIGHT * 12.0
+    end
+
+    # メルカトルX座標から正規化X座標に変換する
+    #    -1.0 <= my <=  +1.0
+    #   -12.0 <= ny <= +12.0
+    def self.mx_to_nx(mx)
+      return mx * 12.0
+    end
+
+    # 正規化Y座標からメルカトルY座標に変換する
+    #   -12.0 <= ny <= +12.0
+    #    -1.0 <= my <=  +1.0
+    def self.ny_to_my(my)
+      return my / 12.0 * DELTA_HEIGHT
+    end
+
+    # 正規化X座標からメルカトルX座標に変換する
+    #   -12.0 <= ny <= +12.0
+    #    -1.0 <= my <=  +1.0
+    def self.nx_to_mx(ny)
+      return ny / 12.0
+    end
+
+    def self.lat_to_ny(lat)
+      return self.my_to_ny(self.lat_to_my(lat))
+    end
+
+    def self.lng_to_nx(lng)
+      return self.mx_to_nx(self.lng_to_mx(lng))
+    end
+
+    def self.ny_to_lat(ny)
+      return self.my_to_lat(self.ny_to_my(ny))
+    end
+
+    def self.nx_to_lng(nx)
+      return self.mx_to_lng(self.nx_to_mx(nx))
+    end
+
+    def self.latlng_to_nxy(lat, lng)
+      return [
+        self.lng_to_nx(lng),
+        self.lat_to_ny(lat),
+      ]
+    end
+
+    def self.nxy_to_latlng(nx, ny)
+      return [
+        self.ny_to_lat(ny),
+        self.nx_to_lng(nx),
+      ]
+    end
+  end
+end

data/lib/geodelta/region.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+require_relative "./delta_geometry"
+
+module GeoDelta
+  module Region
+    def self.get_delta_ids_in_region(x1, y1, x2, y2, level)
+      ids = []
+
+      if x1 > x2
+        ids += self.get_delta_ids_in_region(x1, y1, +12.0, y2, level)
+        ids += self.get_delta_ids_in_region(x2, y1,  +0.0, y2, level)
+      else
+        unit = 12.0 / (2 ** (level - 1))
+        u1   = unit
+        u2   = unit / 2
+
+        nw = GeoDelta::DeltaGeometry.get_delta_ids(x1, y1, level)
+        ne = GeoDelta::DeltaGeometry.get_delta_ids(x2, y1, level)
+        sw = GeoDelta::DeltaGeometry.get_delta_ids(x1, y2, level)
+        se = GeoDelta::DeltaGeometry.get_delta_ids(x2, y2, level)
+
+        proc {
+          sx, y = GeoDelta::DeltaGeometry.get_center(nw)
+          ex, _ = GeoDelta::DeltaGeometry.get_center(ne)
+
+          sx -= 24.0  if sx > ex
+
+          sxi  = (sx / u2).floor
+          exi  = (ex / u2).ceil
+          sxi -= 1 if !GeoDelta::DeltaGeometry.upper_delta?(nw) && x1 < sx && nw != sw
+          exi += 1 if !GeoDelta::DeltaGeometry.upper_delta?(ne) && x2 > ex && ne != se
+
+          (sxi..exi).each { |xi|
+            xx = xi * u2
+            ids << GeoDelta::DeltaGeometry.get_delta_ids(xx, y, level)
+          }
+        }.call
+
+        proc {
+          sx, y = GeoDelta::DeltaGeometry.get_center(sw)
+          ex, _ = GeoDelta::DeltaGeometry.get_center(se)
+
+          sx -= 24.0  if sx > ex
+
+          sxi  = (sx / u2).floor
+          exi  = (ex / u2).ceil
+          sxi -= 1 if GeoDelta::DeltaGeometry.upper_delta?(sw) && x1 < sx && nw != sw
+          exi += 1 if GeoDelta::DeltaGeometry.upper_delta?(se) && x2 > ex && ne != se
+
+          (sxi..exi).each { |xi|
+            xx = xi * u2
+            ids << GeoDelta::DeltaGeometry.get_delta_ids(xx, y, level)
+          }
+        }.call
+
+        proc {
+          syi = (y1 / u1).floor
+          eyi = (y2 / u1).ceil + 1
+          sxi = (x1 / u2).floor
+          exi = (x2 / u2).ceil
+          (eyi..syi).each { |yi|
+            yy = yi * unit - u2
+            (sxi..exi).each { |xi|
+              xx = xi * u2
+              ids << GeoDelta::DeltaGeometry.get_delta_ids(xx, yy, level)
+            }
+          }
+        }.call
+      end
+
+      ids.sort!
+      ids.uniq!
+
+      return ids
+    end
+  end
+end

data/lib/geodelta/version.rb

@@ -0,0 +1,4 @@
+
+module GeoDelta
+  VERSION = "0.0.2"
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: geodelta
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Yuya Kato
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-07-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An implementation of GeoDelta for Ruby.
+email:
+- yuyakato@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- circle.yml
+- geodelta.gemspec
+- lib/geodelta.rb
+- lib/geodelta/core.rb
+- lib/geodelta/delta_geometry.rb
+- lib/geodelta/encoder.rb
+- lib/geodelta/hex_geometry.rb
+- lib/geodelta/hex_region.rb
+- lib/geodelta/id_util.rb
+- lib/geodelta/packer32.rb
+- lib/geodelta/packer64.rb
+- lib/geodelta/projector.rb
+- lib/geodelta/region.rb
+- lib/geodelta/version.rb
+homepage: https://github.com/nayutaya/geodelta-ruby
+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.4.5
+signing_key: 
+specification_version: 4
+summary: An implementation of GeoDelta for Ruby.
+test_files: []