# array of 64 chars to encode 6 bits. this is almost like base64 encoding, but

# the symbolic chars are different, as base64's + and / aren't very

# URL-friendly.

ARRAY = ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a + ['_','@']

##

# Given a string encoding a location, returns the [lon, lat, z] tuple of that

# location.

def self.decode(str)

x = 0

y = 0

z = 0

z_offset = 0

str.each_char do |c|

t = ARRAY.index c

if t.nil?

z_offset -= 1

else

3.times do

x <<= 1; x = x | 1 unless (t & 32).zero?; t <<= 1

y <<= 1; y = y | 1 unless (t & 32).zero?; t <<= 1

end

z += 3

end

end

# pack the coordinates out to their original 32 bits.

x <<= (32 - z)

y <<= (32 - z)

# project the parameters back to their coordinate ranges.

[(x * 360.0 / 2**32) - 180.0,

(y * 180.0 / 2**32) - 90.0,

z - 8 - (z_offset % 3)]

end

##

# given a location and zoom, return a short string representing it.

def self.encode(lon, lat, z)

code = interleave_bits(((lon + 180.0) * 2**32 / 360.0).to_i,

((lat + 90.0) * 2**32 / 180.0).to_i)

str = ""

# add eight to the zoom level, which approximates an accuracy of

# one pixel in a tile.

((z + 8)/3.0).ceil.times do |i|

digit = (code >> (58 - 6 * i)) & 0x3f

str << ARRAY[digit]

end

# append characters onto the end of the string to represent

# partial zoom levels (characters themselves have a granularity

# of 3 zoom levels).

((z + 8) % 3).times { str << "=" }

return str

end

private

##

# interleaves the bits of two 32-bit numbers. the result is known

# as a Morton code.

def self.interleave_bits(x, y)

c = 0

31.downto(0) do |i|

c = (c << 1) | ((x >> i) & 1)

c = (c << 1) | ((y >> i) & 1)

end

c

end