geo_hex 3.1.1

data/lib/geo_hex.rb

@@ -0,0 +1,43 @@
+require 'bigdecimal'
+require 'geo_hex/version'
+require 'geo_hex/ll'
+require 'geo_hex/pp'
+require 'geo_hex/zone'
+require 'geo_hex/unit'
+require 'geo_hex/polygon'
+
+module GeoHex
+  H_KEY  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".freeze
+  H_BASE = 20037508.34
+  H_D2R  = Math::PI / 180.0
+  H_K    = Math.tan(H_D2R * 30)
+  H_ER   = 6_371_007.2
+
+  # @param [Float] lat the latitude
+  # @param [Float] lon the longitude
+  # @param [Integer] level the level
+  # @return [GeoHex::Zone] the encoded zone
+  def self.encode(lat, lon, level = 7)
+    LL.new(lat, lon).to_zone(level)
+  end
+
+  # @param [String] code the GeoHex code
+  # @return [GeoHex::Zone] the decoded zone
+  def self.decode(code)
+    x, y   = 0, 0
+    chars  = code.size
+    string = "#{H_KEY.index(code[0]) * 30 + H_KEY.index(code[1])}#{code[2..-1]}"
+    string = string.rjust(chars+1, "0")
+    nums   = string.chars.map {|c| c.to_i }
+    nums.each_with_index do |num, i|
+      pow = 3**(chars-i)
+      num = num.to_s(3).to_i
+
+      case (num / 10) when 0 then x -= pow when 2 then x += pow end
+      case (num % 10) when 0 then y -= pow when 2 then y += pow end
+    end
+
+    Zone.new(x, y, chars-2).send(:with_code, code)
+  end
+
+end

data/lib/geo_hex/ll.rb

@@ -0,0 +1,61 @@
+module GeoHex
+
+  # Lat/Lon coordinates
+  class LL
+
+    # @return [Float] longitude
+    def self.normalize(lon)
+      if lon < -180
+        lon += 360
+      elsif lon > 180
+        lon -= 360
+      else
+        lon
+      end
+    end
+
+    attr_reader :lat, :lon
+
+    # @param [Float] lat the latitude
+    # @param [Float] lon the longitude
+    def initialize(lat, lon)
+      @lat, @lon = lat, self.class.normalize(lon)
+    end
+
+    # @return [Float] mercator easting
+    def easting
+      @easting ||= lon * H_BASE / 180.0
+    end
+
+    # @return [Float] mercator northing
+    def northing
+      @northing ||= Math.log(Math.tan((90 + lat) * H_D2R / 2)) / Math::PI * H_BASE
+    end
+
+    # @return [GeoHex::PP] the full projection point coordinates
+    def to_pp
+      GeoHex::PP.new(easting, northing)
+    end
+
+    # Converts coordinates to Zone
+    # @param [Integer] level the level
+    # @return [GeoHex::Zone] the coordinates
+    def to_zone(level)
+      to_pp.to_zone(level)
+    end
+
+    # @param [GeoHex::PP] other coordinates
+    # @return [Float] distance in meters
+    def distance_to(other)
+      d_lat, d_lon = (other.lat - lat) * H_D2R / 2.0, (other.lon - lon) * H_D2R / 2.0
+      lat1, lat2   = lat * H_D2R, other.lat * H_D2R
+
+      a = Math.sin(d_lat) ** 2 +
+          Math.sin(d_lon) ** 2 * Math.cos(lat1) * Math.cos(lat2)
+      c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
+
+      H_ER * c
+    end
+
+  end
+end

data/lib/geo_hex/polygon.rb

@@ -0,0 +1,90 @@
+module GeoHex
+
+  class Polygon < Struct.new(:easting, :northing, :size)
+    H_K = Math.tan(Math::PI / 180.0 * 60)
+
+    # @return [GeoHex::PP] The Centroid of the Polygon
+    def centroid
+      @centroid ||= PP.new(easting, northing)
+    end
+    alias_method :c, :centroid
+
+    # @return [GeoHex::PP] The Northeast point of the Polygon
+    def north_east
+      @north_east ||= PP.new(east_bound, north_bound)
+    end
+    alias_method :ne, :north_east
+
+    # @return [GeoHex::PP] The East point of the Polygon
+    def east
+      @east ||= PP.new(easting + 2 * size, northing)
+    end
+    alias_method :e, :east
+
+    # @return [GeoHex::PP] The Southeast point of the Polygon
+    def south_east
+      @south_east ||= PP.new(east_bound, south_bound)
+    end
+    alias_method :se, :south_east
+
+    # @return [GeoHex::PP] The Southwest point of the Polygon
+    def south_west
+      @south_west ||= PP.new(west_bound, south_bound)
+    end
+    alias_method :sw, :south_west
+
+    # @return [GeoHex::PP] The West point of the Polygon
+    def west
+      @west ||= PP.new(easting - 2 * size, northing)
+    end
+    alias_method :w, :west
+
+    # @return [GeoHex::PP] The Northwest point of the Polygon
+    def north_west
+      @north_west ||= PP.new(west_bound, north_bound)
+    end
+    alias_method :nw, :north_west
+
+    # @return [GeoHex::PP] Point in the middle of the northern polygon boundary
+    def north
+      @north ||= PP.new(easting, north_bound)
+    end
+    alias_method :n, :north
+
+    # @return [GeoHex::PP] Point in the middle of the southern polygon boundary
+    def south
+      @south ||= PP.new(easting, south_bound)
+    end
+    alias_method :s, :south
+
+    # @return [Array<GeoHex::PP>] All the points of the Polygon, ordered from Northeast round to Northwest
+    def points
+      @points ||= [ne, e, se, sw, w, nw]
+    end
+    alias_method :to_a, :points
+
+    private
+
+      # @return [Float] The northing of the Northern boundary of the Polygon
+      def north_bound
+        @north_bound ||= northing + H_K * size
+      end
+
+      # @return [Float] The easting of both Eastern corners of the Polygon
+      def east_bound
+        @east_bound ||= easting + size
+      end
+
+      # @return [Float] The northing of the Southern boundary of the Polygon
+      def south_bound
+        @south_bound ||= northing - H_K * size
+      end
+
+      # @return [Float] The easting of both Western corners of the Polygon
+      def west_bound
+        @west_bound  ||= easting - size
+      end
+
+  end
+
+end

data/lib/geo_hex/pp.rb

@@ -0,0 +1,44 @@
+module GeoHex
+
+  # Mercator projection point
+  class PP < Struct.new(:easting, :northing)
+
+    # @return [Float] longitude
+    def lon
+      @lon ||= LL.normalize(easting / H_BASE * 180.0)
+    end
+
+    # @return [Float] latitude
+    def lat
+      @lat ||= 180.0 / Math::PI * (2 * Math.atan(Math.exp(northing / H_BASE * 180.0 * H_D2R)) - Math::PI / 2.0)
+    end
+
+    # @return [GeoHex::LL] lat/lon coordinates
+    def to_ll
+      LL.new(lat, lon)
+    end
+
+    # Converts point coordinates into a Zone for a given `level`
+    # @param [Integer] level the level
+    # @return [GeoHex::Zone] the zone
+    def to_zone(level)
+      u = Unit[level]
+      x = (easting + northing / H_K) / u.width
+      y = (northing - H_K * easting) / u.height
+
+      x0, y0 = x.floor, y.floor
+      xq, yq = x - x0, y - y0
+      xn, yn = if yq > -xq + 1 && yq < 2 * xq && yq > 0.5 * xq
+        [x0 + 1, y0 + 1]
+      elsif yq < -xq + 1 && yq > 2 * xq - 1 && yq < 0.5 * xq + 0.5
+        [x0, y0]
+      else
+        [x.round, y.round]
+      end
+
+      Zone.new(xn, yn, level)
+    end
+
+  end
+
+end

data/lib/geo_hex/unit.rb

@@ -0,0 +1,56 @@
+module GeoHex
+
+  # A Unit is a class of Zones. It has a `level`, `width`, `height` and
+  # overall `size`. Dimensions vary for different levels.
+  class Unit
+
+    class << self
+      private :new
+
+      # @return [Boolean] true if unit caching is enabled, defaults to false
+      def cache?
+        @cache == true
+      end
+
+      # @param [Boolean] value set to true to enable caching (recommended)
+      def cache=(value)
+        @cache = value
+      end
+
+      # @return [Hash] cache store
+      def store
+        @store ||= {}
+      end
+
+      # @param [Integer] level
+      # @return [GeoHex::Unit] for the given level
+      def [](level)
+        cache? ? store[level] ||= new(level) : new(level)
+      end
+
+    end
+
+    attr_reader :level
+
+    # @param [Integer] level
+    def initialize(level)
+      @level = level
+    end
+
+    # @return [Float] unit's mercator size
+    def size
+      @size ||= H_BASE / 3**(level+3)
+    end
+
+    # @return [Float] unit's mercator width
+    def width
+      @width ||= 6.0 * size
+    end
+
+    # @return [Float] unit's mercator height
+    def height
+      @height ||= width * H_K
+    end
+
+  end
+end

data/lib/geo_hex/version.rb

@@ -0,0 +1,3 @@
+module GeoHex
+  VERSION = "3.1.1".freeze
+end

data/lib/geo_hex/zone.rb

@@ -0,0 +1,155 @@
+module GeoHex
+
+  # A positioned instance of a Unit, within a level-grid
+  class Zone
+
+    # @return [Integer] the zone coordinates within the grid
+    attr_reader :x, :y
+
+    # @return [GeoHex::Unit] the associated unit
+    attr_reader :unit
+
+    # @return [Float] the mercator northing
+    attr_reader :northing
+
+    # @return [Float] the mercator easting
+    attr_reader :easting
+
+    # @param [Integer] x the horizontal index
+    # @param [Integer] y the vertical index
+    # @param [Integer] level the level
+    def initialize(x, y, level)
+      @x, @y    = x, y
+      @unit     = Unit[level]
+      @northing = (H_K * @x * @unit.width + @y * @unit.height) / 2.0
+      @easting  = (@northing - @y * @unit.height) / H_K
+      @x, @y    = @y, @x if meridian_180?
+    end
+
+    # @return [Integer] the level
+    def level
+      unit.level
+    end
+
+    # @return [Float] the longitude coordinate
+    def lon
+      meridian_180? ? 180.0 : point.lon
+    end
+
+    # @return [Float] the latitude coordinate
+    def lat
+      point.lat
+    end
+
+    # @return [String] GeoHex code
+    def code
+      @code ||= encode
+    end
+    alias_method :to_s, :code
+
+    # @return [GeoHex::PP] zone center, point coordinates
+    def point
+      @point ||= GeoHex::PP.new(easting, northing)
+    end
+
+    # @return [<GeoHex::Polygon>] Zone's NE, E, SE, SW, W and NW points
+    def polygon
+      @polygon ||= GeoHex::Polygon.new(easting, northing, unit.size)
+    end
+
+    # @param [Integer] range the number of zones to search within
+    # @return [Array<GeoHex::Zone>] the neighbouring zones
+    def neighbours(range)
+      zones  = []
+      x0, xn = x - range, x + range
+
+      x0.upto(xn) do |xi|
+        zones << self.class.new(xi, y, level) unless xi == x
+      end
+
+      1.upto(range) do |i|
+        y+i % 2 == 1 ? xn-=1 : x0+=1
+
+        x0.upto(xn) do |xi|
+          zones << self.class.new(xi, y+i, level)
+          zones << self.class.new(xi, y-i, level)
+        end
+      end
+
+      zones
+    end
+    alias_method :neighbors, :neighbours
+
+    # @param [Zone, String] other another Zone or a GeoHex code (String)
+    # @return [Boolean] true, if given Zone or GeoHex code (String) matches self
+    def ==(other)
+      case other
+      when String
+        to_s == other
+      when self.class
+        x == other.x && y == other.y && level == other.level
+      else
+        super
+      end
+    end
+    alias_method :eql?, :==
+
+    # @return [Fixnum] the object hash
+    def hash
+      [x, y, level].hash
+    end
+
+    protected
+
+      # @param [String] code the GeoHex code
+      # @return [GeoHex::Zone] GeoHex zone
+      def with_code(code)
+        @code = code
+        self
+      end
+
+    private
+
+      # @return [String] GeoHex code
+      def encode
+        code, mod_x, mod_y = "", self.x, self.y
+
+        (0..level+2).reverse_each do |i|
+          pow = 3 ** i
+          p2c = (pow / 2.0).ceil
+
+          c3_x = if mod_x >= p2c
+            mod_x -= pow
+            2
+          elsif mod_x <= -p2c
+            mod_x += pow
+            0
+          else
+            1
+          end
+
+          c3_y = if mod_y >= p2c
+            mod_y -= pow
+            2
+          elsif mod_y <= -p2c
+            mod_y += pow
+            0
+          else
+            1
+          end
+
+          code << Integer([c3_x, c3_y].join, 3).to_s
+        end
+
+        number = code[0..2].to_i
+        "#{H_KEY[number / 30]}#{H_KEY[number % 30]}#{code[3..-1]}"
+      end
+
+      # @return [Boolean] true if the zone is placed on the 180th meridian
+      def meridian_180?
+        return @meridian_180 if defined?(@meridian_180)
+        @meridian_180 = H_BASE - easting < unit.size
+      end
+
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: geo_hex
+version: !ruby/object:Gem::Version
+  version: 3.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Dimitrij Denissenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby implementation of GeoHex encoding algorithm
+email: dimitrij@blacksquaremedia.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/geo_hex/unit.rb
+- lib/geo_hex/ll.rb
+- lib/geo_hex/polygon.rb
+- lib/geo_hex/version.rb
+- lib/geo_hex/pp.rb
+- lib/geo_hex/zone.rb
+- lib/geo_hex.rb
+homepage: https://github.com/bsm/geo_hex
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: GeoHex (V3)
+test_files: []